Coverage Report


Files: 40
Lines: 22386
Covered: 14 / 184 (7.6%)


Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
abstract contract Asserts {
5
    function gt(uint256 a, uint256 b, string memory reason) internal virtual;
6

                            
                        
7
    function gte(uint256 a, uint256 b, string memory reason) internal virtual;
8

                            
                        
9
    function lt(uint256 a, uint256 b, string memory reason) internal virtual;
10

                            
                        
11
    function lte(uint256 a, uint256 b, string memory reason) internal virtual;
12

                            
                        
13
    function eq(uint256 a, uint256 b, string memory reason) internal virtual;
14

                            
                        
15
    function t(bool b, string memory reason) internal virtual;
16

                            
                        
17
    function between(uint256 value, uint256 low, uint256 high) internal virtual returns (uint256);
18

                            
                        
19
    function between(int256 value, int256 low, int256 high) internal virtual returns (int256);
20

                            
                        
21
    function precondition(bool p) internal virtual;
22
}
23

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
import {BaseSetup} from "./BaseSetup.sol";
5

                            
                        
6
abstract contract BaseProperties is BaseSetup {}
7

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
abstract contract BaseSetup {
5
    function setup() internal virtual;
6
}
7

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
import {BaseProperties} from "./BaseProperties.sol";
5
import {Asserts} from "./Asserts.sol";
6

                            
                        
7
abstract contract BaseTargetFunctions is BaseProperties, Asserts {}
8

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
import {Asserts} from "./Asserts.sol";
5

                            
                        
6
contract CryticAsserts is Asserts {
7
    event Log(string);
8

                            
                        
9
    function gt(uint256 a, uint256 b, string memory reason) internal virtual override {
10
        if (!(a > b)) {
11
            emit Log(reason);
12
            assert(false);
13
        }
14
    }
15

                            
                        
16
    function gte(uint256 a, uint256 b, string memory reason) internal virtual override {
17
        if (!(a >= b)) {
18
            emit Log(reason);
19
            assert(false);
20
        }
21
    }
22

                            
                        
23
    function lt(uint256 a, uint256 b, string memory reason) internal virtual override {
24
        if (!(a < b)) {
25
            emit Log(reason);
26
            assert(false);
27
        }
28
    }
29

                            
                        
30
    function lte(uint256 a, uint256 b, string memory reason) internal virtual override {
31
        if (!(a <= b)) {
32
            emit Log(reason);
33
            assert(false);
34
        }
35
    }
36

                            
                        
37
    function eq(uint256 a, uint256 b, string memory reason) internal virtual override {
38
        if (!(a == b)) {
39
            emit Log(reason);
40
            assert(false);
41
        }
42
    }
43

                            
                        
44
    function t(bool b, string memory reason) internal virtual override {
45
        if (!b) {
46
            emit Log(reason);
47
            assert(false);
48
        }
49
    }
50

                            
                        
51
    function between(uint256 value, uint256 low, uint256 high) internal virtual override returns (uint256) {
52
        if (value < low || value > high) {
53
            uint256 ans = low + (value % (high - low + 1));
54
            return ans;
55
        }
56
        return value;
57
    }
58

                            
                        
59
    function between(int256 value, int256 low, int256 high) internal virtual override returns (int256) {
60
        if (value < low || value > high) {
61
            int256 range = high - low + 1;
62
            int256 clamped = (value - low) % (range);
63
            if (clamped < 0) clamped += range;
64
            int256 ans = low + clamped;
65
            return ans;
66
        }
67
        return value;
68
    }
69

                            
                        
70
    function precondition(bool p) internal virtual override {
71
        require(p);
72
    }
73
}
74

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
import {Test} from "forge-std/Test.sol";
5
import {Asserts} from "./Asserts.sol";
6

                            
                        
7
contract FoundryAsserts is Test, Asserts {
8
    function gt(uint256 a, uint256 b, string memory reason) internal virtual override {
9
        assertGt(a, b, reason);
10
    }
11

                            
                        
12
    function gte(uint256 a, uint256 b, string memory reason) internal virtual override {
13
        assertGe(a, b, reason);
14
    }
15

                            
                        
16
    function lt(uint256 a, uint256 b, string memory reason) internal virtual override {
17
        assertLt(a, b, reason);
18
    }
19

                            
                        
20
    function lte(uint256 a, uint256 b, string memory reason) internal virtual override {
21
        assertLe(a, b, reason);
22
    }
23

                            
                        
24
    function eq(uint256 a, uint256 b, string memory reason) internal virtual override {
25
        assertEq(a, b, reason);
26
    }
27

                            
                        
28
    function t(bool b, string memory reason) internal virtual override {
29
        assertTrue(b, reason);
30
    }
31

                            
                        
32
    function between(uint256 value, uint256 low, uint256 high) internal virtual override returns (uint256) {
33
        if (value < low || value > high) {
34
            uint256 ans = low + (value % (high - low + 1));
35
            return ans;
36
        }
37
        return value;
38
    }
39

                            
                        
40
    function between(int256 value, int256 low, int256 high) internal virtual override returns (int256) {
41
        if (value < low || value > high) {
42
            int256 range = high - low + 1;
43
            int256 clamped = (value - low) % (range);
44
            if (clamped < 0) clamped += range;
45
            int256 ans = low + clamped;
46
            return ans;
47
        }
48
        return value;
49
    }
50

                            
                        
51
    function precondition(bool p) internal virtual override {
52
        vm.assume(p);
53
    }
54
}
55

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

                            
                        
4
// slither-disable-start shadowing-local
5

                            
                        
6
interface IHevm {
7
    // Set block.timestamp to newTimestamp
8
    function warp(uint256 newTimestamp) external;
9

                            
                        
10
    // Set block.number to newNumber
11
    function roll(uint256 newNumber) external;
12

                            
                        
13
    // Add the condition b to the assumption base for the current branch
14
    // This function is almost identical to require
15
    function assume(bool b) external;
16

                            
                        
17
    // Sets the eth balance of usr to amt
18
    function deal(address usr, uint256 amt) external;
19

                            
                        
20
    // Loads a storage slot from an address
21
    function load(address where, bytes32 slot) external returns (bytes32);
22

                            
                        
23
    // Stores a value to an address' storage slot
24
    function store(address where, bytes32 slot, bytes32 value) external;
25

                            
                        
26
    // Signs data (privateKey, digest) => (v, r, s)
27
    function sign(uint256 privateKey, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
28

                            
                        
29
    // Gets address for a given private key
30
    function addr(uint256 privateKey) external returns (address addr);
31

                            
                        
32
    // Performs a foreign function call via terminal
33
    function ffi(string[] calldata inputs) external returns (bytes memory result);
34

                            
                        
35
    // Performs the next smart contract call with specified `msg.sender`
36
    function prank(address newSender) external;
37

                            
                        
38
    // Creates a new fork with the given endpoint and the latest block and returns the identifier of the fork
39
    function createFork(string calldata urlOrAlias) external returns (uint256);
40

                            
                        
41
    // Takes a fork identifier created by createFork and sets the corresponding forked state as active
42
    function selectFork(uint256 forkId) external;
43

                            
                        
44
    // Returns the identifier of the current fork
45
    function activeFork() external returns (uint256);
46

                            
                        
47
    // Labels the address in traces
48
    function label(address addr, string calldata label) external;
49

                            
                        
50
    /// Sets an address' code.
51
    function etch(address target, bytes calldata newRuntimeBytecode) external;
52
}
53

                            
                        
54
IHevm constant vm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
55

                            
                        
56
// slither-disable-end shadowing-local
57

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
import {StdStorage} from "./StdStorage.sol";
5
import {Vm, VmSafe} from "./Vm.sol";
6

                            
                        
7
abstract contract CommonBase {
8
    // Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D.
9
    address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
10
    // console.sol and console2.sol work by executing a staticcall to this address.
11
    address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
12
    // Used when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
13
    address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
14
    // Default address for tx.origin and msg.sender, 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38.
15
    address internal constant DEFAULT_SENDER = address(uint160(uint256(keccak256("foundry default caller"))));
16
    // Address of the test contract, deployed by the DEFAULT_SENDER.
17
    address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
18
    // Deterministic deployment address of the Multicall3 contract.
19
    address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
20
    // The order of the secp256k1 curve.
21
    uint256 internal constant SECP256K1_ORDER =
22
        115792089237316195423570985008687907852837564279074904382605163141518161494337;
23

                            
                        
24
    uint256 internal constant UINT256_MAX =
25
        115792089237316195423570985008687907853269984665640564039457584007913129639935;
26

                            
                        
27
    Vm internal constant vm = Vm(VM_ADDRESS);
28
    StdStorage internal stdstore;
29
}
30

                            
                        
31
abstract contract TestBase is CommonBase {}
32

                            
                        
33
abstract contract ScriptBase is CommonBase {
34
    VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
35
}
36

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
// 💬 ABOUT
5
// Forge Std's default Script.
6

                            
                        
7
// 🧩 MODULES
8
import {console} from "./console.sol";
9
import {console2} from "./console2.sol";
10
import {safeconsole} from "./safeconsole.sol";
11
import {StdChains} from "./StdChains.sol";
12
import {StdCheatsSafe} from "./StdCheats.sol";
13
import {stdJson} from "./StdJson.sol";
14
import {stdMath} from "./StdMath.sol";
15
import {StdStorage, stdStorageSafe} from "./StdStorage.sol";
16
import {StdStyle} from "./StdStyle.sol";
17
import {StdUtils} from "./StdUtils.sol";
18
import {VmSafe} from "./Vm.sol";
19

                            
                        
20
// 📦 BOILERPLATE
21
import {ScriptBase} from "./Base.sol";
22

                            
                        
23
// ⭐️ SCRIPT
24
abstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {
25
    // Note: IS_SCRIPT() must return true.
26
    bool public IS_SCRIPT = true;
27
}
28

                            
                        

Lines covered: 0 / 5 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3
pragma experimental ABIEncoderV2;
4

                            
                        
5
import {Vm} from "./Vm.sol";
6

                            
                        
7
abstract contract StdAssertions {
8
    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
9

                            
                        
10
    event log(string);
11
    event logs(bytes);
12

                            
                        
13
    event log_address(address);
14
    event log_bytes32(bytes32);
15
    event log_int(int256);
16
    event log_uint(uint256);
17
    event log_bytes(bytes);
18
    event log_string(string);
19

                            
                        
20
    event log_named_address(string key, address val);
21
    event log_named_bytes32(string key, bytes32 val);
22
    event log_named_decimal_int(string key, int256 val, uint256 decimals);
23
    event log_named_decimal_uint(string key, uint256 val, uint256 decimals);
24
    event log_named_int(string key, int256 val);
25
    event log_named_uint(string key, uint256 val);
26
    event log_named_bytes(string key, bytes val);
27
    event log_named_string(string key, string val);
28

                            
                        
29
    event log_array(uint256[] val);
30
    event log_array(int256[] val);
31
    event log_array(address[] val);
32
    event log_named_array(string key, uint256[] val);
33
    event log_named_array(string key, int256[] val);
34
    event log_named_array(string key, address[] val);
35

                            
                        
36
    bool private _failed;
37

                            
                        
38
    function failed() public view returns (bool) {
39
        if (_failed) {
40
            return _failed;
41
        } else {
42
            return vm.load(address(vm), bytes32("failed")) != bytes32(0);
43
        }
44
    }
45

                            
                        
46
    function fail() internal virtual {
47
        vm.store(address(vm), bytes32("failed"), bytes32(uint256(1)));
48
        _failed = true;
49
    }
50

                            
                        
51
    function assertTrue(bool data) internal pure virtual {
52
        vm.assertTrue(data);
53
    }
54

                            
                        
55
    function assertTrue(bool data, string memory err) internal pure virtual {
56
        vm.assertTrue(data, err);
57
    }
58

                            
                        
59
    function assertFalse(bool data) internal pure virtual {
60
        vm.assertFalse(data);
61
    }
62

                            
                        
63
    function assertFalse(bool data, string memory err) internal pure virtual {
64
        vm.assertFalse(data, err);
65
    }
66

                            
                        
67
    function assertEq(bool left, bool right) internal pure virtual {
68
        vm.assertEq(left, right);
69
    }
70

                            
                        
71
    function assertEq(bool left, bool right, string memory err) internal pure virtual {
72
        vm.assertEq(left, right, err);
73
    }
74

                            
                        
75
    function assertEq(uint256 left, uint256 right) internal pure virtual {
76
        vm.assertEq(left, right);
77
    }
78

                            
                        
79
    function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {
80
        vm.assertEq(left, right, err);
81
    }
82

                            
                        
83
    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
84
        vm.assertEqDecimal(left, right, decimals);
85
    }
86

                            
                        
87
    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
88
        vm.assertEqDecimal(left, right, decimals, err);
89
    }
90

                            
                        
91
    function assertEq(int256 left, int256 right) internal pure virtual {
92
        vm.assertEq(left, right);
93
    }
94

                            
                        
95
    function assertEq(int256 left, int256 right, string memory err) internal pure virtual {
96
        vm.assertEq(left, right, err);
97
    }
98

                            
                        
99
    function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
100
        vm.assertEqDecimal(left, right, decimals);
101
    }
102

                            
                        
103
    function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
104
        vm.assertEqDecimal(left, right, decimals, err);
105
    }
106

                            
                        
107
    function assertEq(address left, address right) internal pure virtual {
108
        vm.assertEq(left, right);
109
    }
110

                            
                        
111
    function assertEq(address left, address right, string memory err) internal pure virtual {
112
        vm.assertEq(left, right, err);
113
    }
114

                            
                        
115
    function assertEq(bytes32 left, bytes32 right) internal pure virtual {
116
        vm.assertEq(left, right);
117
    }
118

                            
                        
119
    function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
120
        vm.assertEq(left, right, err);
121
    }
122

                            
                        
123
    function assertEq32(bytes32 left, bytes32 right) internal pure virtual {
124
        assertEq(left, right);
125
    }
126

                            
                        
127
    function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
128
        assertEq(left, right, err);
129
    }
130

                            
                        
131
    function assertEq(string memory left, string memory right) internal pure virtual {
132
        vm.assertEq(left, right);
133
    }
134

                            
                        
135
    function assertEq(string memory left, string memory right, string memory err) internal pure virtual {
136
        vm.assertEq(left, right, err);
137
    }
138

                            
                        
139
    function assertEq(bytes memory left, bytes memory right) internal pure virtual {
140
        vm.assertEq(left, right);
141
    }
142

                            
                        
143
    function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
144
        vm.assertEq(left, right, err);
145
    }
146

                            
                        
147
    function assertEq(bool[] memory left, bool[] memory right) internal pure virtual {
148
        vm.assertEq(left, right);
149
    }
150

                            
                        
151
    function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
152
        vm.assertEq(left, right, err);
153
    }
154

                            
                        
155
    function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
156
        vm.assertEq(left, right);
157
    }
158

                            
                        
159
    function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
160
        vm.assertEq(left, right, err);
161
    }
162

                            
                        
163
    function assertEq(int256[] memory left, int256[] memory right) internal pure virtual {
164
        vm.assertEq(left, right);
165
    }
166

                            
                        
167
    function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
168
        vm.assertEq(left, right, err);
169
    }
170

                            
                        
171
    function assertEq(address[] memory left, address[] memory right) internal pure virtual {
172
        vm.assertEq(left, right);
173
    }
174

                            
                        
175
    function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
176
        vm.assertEq(left, right, err);
177
    }
178

                            
                        
179
    function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
180
        vm.assertEq(left, right);
181
    }
182

                            
                        
183
    function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
184
        vm.assertEq(left, right, err);
185
    }
186

                            
                        
187
    function assertEq(string[] memory left, string[] memory right) internal pure virtual {
188
        vm.assertEq(left, right);
189
    }
190

                            
                        
191
    function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
192
        vm.assertEq(left, right, err);
193
    }
194

                            
                        
195
    function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
196
        vm.assertEq(left, right);
197
    }
198

                            
                        
199
    function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
200
        vm.assertEq(left, right, err);
201
    }
202

                            
                        
203
    // Legacy helper
204
    function assertEqUint(uint256 left, uint256 right) internal pure virtual {
205
        assertEq(left, right);
206
    }
207

                            
                        
208
    function assertNotEq(bool left, bool right) internal pure virtual {
209
        vm.assertNotEq(left, right);
210
    }
211

                            
                        
212
    function assertNotEq(bool left, bool right, string memory err) internal pure virtual {
213
        vm.assertNotEq(left, right, err);
214
    }
215

                            
                        
216
    function assertNotEq(uint256 left, uint256 right) internal pure virtual {
217
        vm.assertNotEq(left, right);
218
    }
219

                            
                        
220
    function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {
221
        vm.assertNotEq(left, right, err);
222
    }
223

                            
                        
224
    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
225
        vm.assertNotEqDecimal(left, right, decimals);
226
    }
227

                            
                        
228
    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err)
229
        internal
230
        pure
231
        virtual
232
    {
233
        vm.assertNotEqDecimal(left, right, decimals, err);
234
    }
235

                            
                        
236
    function assertNotEq(int256 left, int256 right) internal pure virtual {
237
        vm.assertNotEq(left, right);
238
    }
239

                            
                        
240
    function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {
241
        vm.assertNotEq(left, right, err);
242
    }
243

                            
                        
244
    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
245
        vm.assertNotEqDecimal(left, right, decimals);
246
    }
247

                            
                        
248
    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
249
        vm.assertNotEqDecimal(left, right, decimals, err);
250
    }
251

                            
                        
252
    function assertNotEq(address left, address right) internal pure virtual {
253
        vm.assertNotEq(left, right);
254
    }
255

                            
                        
256
    function assertNotEq(address left, address right, string memory err) internal pure virtual {
257
        vm.assertNotEq(left, right, err);
258
    }
259

                            
                        
260
    function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {
261
        vm.assertNotEq(left, right);
262
    }
263

                            
                        
264
    function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
265
        vm.assertNotEq(left, right, err);
266
    }
267

                            
                        
268
    function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {
269
        assertNotEq(left, right);
270
    }
271

                            
                        
272
    function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
273
        assertNotEq(left, right, err);
274
    }
275

                            
                        
276
    function assertNotEq(string memory left, string memory right) internal pure virtual {
277
        vm.assertNotEq(left, right);
278
    }
279

                            
                        
280
    function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual {
281
        vm.assertNotEq(left, right, err);
282
    }
283

                            
                        
284
    function assertNotEq(bytes memory left, bytes memory right) internal pure virtual {
285
        vm.assertNotEq(left, right);
286
    }
287

                            
                        
288
    function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
289
        vm.assertNotEq(left, right, err);
290
    }
291

                            
                        
292
    function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual {
293
        vm.assertNotEq(left, right);
294
    }
295

                            
                        
296
    function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
297
        vm.assertNotEq(left, right, err);
298
    }
299

                            
                        
300
    function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
301
        vm.assertNotEq(left, right);
302
    }
303

                            
                        
304
    function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
305
        vm.assertNotEq(left, right, err);
306
    }
307

                            
                        
308
    function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual {
309
        vm.assertNotEq(left, right);
310
    }
311

                            
                        
312
    function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
313
        vm.assertNotEq(left, right, err);
314
    }
315

                            
                        
316
    function assertNotEq(address[] memory left, address[] memory right) internal pure virtual {
317
        vm.assertNotEq(left, right);
318
    }
319

                            
                        
320
    function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
321
        vm.assertNotEq(left, right, err);
322
    }
323

                            
                        
324
    function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
325
        vm.assertNotEq(left, right);
326
    }
327

                            
                        
328
    function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
329
        vm.assertNotEq(left, right, err);
330
    }
331

                            
                        
332
    function assertNotEq(string[] memory left, string[] memory right) internal pure virtual {
333
        vm.assertNotEq(left, right);
334
    }
335

                            
                        
336
    function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
337
        vm.assertNotEq(left, right, err);
338
    }
339

                            
                        
340
    function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
341
        vm.assertNotEq(left, right);
342
    }
343

                            
                        
344
    function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
345
        vm.assertNotEq(left, right, err);
346
    }
347

                            
                        
348
    function assertLt(uint256 left, uint256 right) internal pure virtual {
349
        vm.assertLt(left, right);
350
    }
351

                            
                        
352
    function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {
353
        vm.assertLt(left, right, err);
354
    }
355

                            
                        
356
    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
357
        vm.assertLtDecimal(left, right, decimals);
358
    }
359

                            
                        
360
    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
361
        vm.assertLtDecimal(left, right, decimals, err);
362
    }
363

                            
                        
364
    function assertLt(int256 left, int256 right) internal pure virtual {
365
        vm.assertLt(left, right);
366
    }
367

                            
                        
368
    function assertLt(int256 left, int256 right, string memory err) internal pure virtual {
369
        vm.assertLt(left, right, err);
370
    }
371

                            
                        
372
    function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
373
        vm.assertLtDecimal(left, right, decimals);
374
    }
375

                            
                        
376
    function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
377
        vm.assertLtDecimal(left, right, decimals, err);
378
    }
379

                            
                        
380
    function assertGt(uint256 left, uint256 right) internal pure virtual {
381
        vm.assertGt(left, right);
382
    }
383

                            
                        
384
    function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {
385
        vm.assertGt(left, right, err);
386
    }
387

                            
                        
388
    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
389
        vm.assertGtDecimal(left, right, decimals);
390
    }
391

                            
                        
392
    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
393
        vm.assertGtDecimal(left, right, decimals, err);
394
    }
395

                            
                        
396
    function assertGt(int256 left, int256 right) internal pure virtual {
397
        vm.assertGt(left, right);
398
    }
399

                            
                        
400
    function assertGt(int256 left, int256 right, string memory err) internal pure virtual {
401
        vm.assertGt(left, right, err);
402
    }
403

                            
                        
404
    function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
405
        vm.assertGtDecimal(left, right, decimals);
406
    }
407

                            
                        
408
    function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
409
        vm.assertGtDecimal(left, right, decimals, err);
410
    }
411

                            
                        
412
    function assertLe(uint256 left, uint256 right) internal pure virtual {
413
        vm.assertLe(left, right);
414
    }
415

                            
                        
416
    function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {
417
        vm.assertLe(left, right, err);
418
    }
419

                            
                        
420
    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
421
        vm.assertLeDecimal(left, right, decimals);
422
    }
423

                            
                        
424
    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
425
        vm.assertLeDecimal(left, right, decimals, err);
426
    }
427

                            
                        
428
    function assertLe(int256 left, int256 right) internal pure virtual {
429
        vm.assertLe(left, right);
430
    }
431

                            
                        
432
    function assertLe(int256 left, int256 right, string memory err) internal pure virtual {
433
        vm.assertLe(left, right, err);
434
    }
435

                            
                        
436
    function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
437
        vm.assertLeDecimal(left, right, decimals);
438
    }
439

                            
                        
440
    function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
441
        vm.assertLeDecimal(left, right, decimals, err);
442
    }
443

                            
                        
444
    function assertGe(uint256 left, uint256 right) internal pure virtual {
445
        vm.assertGe(left, right);
446
    }
447

                            
                        
448
    function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {
449
        vm.assertGe(left, right, err);
450
    }
451

                            
                        
452
    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
453
        vm.assertGeDecimal(left, right, decimals);
454
    }
455

                            
                        
456
    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
457
        vm.assertGeDecimal(left, right, decimals, err);
458
    }
459

                            
                        
460
    function assertGe(int256 left, int256 right) internal pure virtual {
461
        vm.assertGe(left, right);
462
    }
463

                            
                        
464
    function assertGe(int256 left, int256 right, string memory err) internal pure virtual {
465
        vm.assertGe(left, right, err);
466
    }
467

                            
                        
468
    function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
469
        vm.assertGeDecimal(left, right, decimals);
470
    }
471

                            
                        
472
    function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
473
        vm.assertGeDecimal(left, right, decimals, err);
474
    }
475

                            
                        
476
    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual {
477
        vm.assertApproxEqAbs(left, right, maxDelta);
478
    }
479

                            
                        
480
    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err)
481
        internal
482
        pure
483
        virtual
484
    {
485
        vm.assertApproxEqAbs(left, right, maxDelta, err);
486
    }
487

                            
                        
488
    function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)
489
        internal
490
        pure
491
        virtual
492
    {
493
        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
494
    }
495

                            
                        
496
    function assertApproxEqAbsDecimal(
497
        uint256 left,
498
        uint256 right,
499
        uint256 maxDelta,
500
        uint256 decimals,
501
        string memory err
502
    ) internal pure virtual {
503
        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
504
    }
505

                            
                        
506
    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual {
507
        vm.assertApproxEqAbs(left, right, maxDelta);
508
    }
509

                            
                        
510
    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual {
511
        vm.assertApproxEqAbs(left, right, maxDelta, err);
512
    }
513

                            
                        
514
    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)
515
        internal
516
        pure
517
        virtual
518
    {
519
        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
520
    }
521

                            
                        
522
    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)
523
        internal
524
        pure
525
        virtual
526
    {
527
        vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
528
    }
529

                            
                        
530
    function assertApproxEqRel(
531
        uint256 left,
532
        uint256 right,
533
        uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
534
    ) internal pure virtual {
535
        vm.assertApproxEqRel(left, right, maxPercentDelta);
536
    }
537

                            
                        
538
    function assertApproxEqRel(
539
        uint256 left,
540
        uint256 right,
541
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
542
        string memory err
543
    ) internal pure virtual {
544
        vm.assertApproxEqRel(left, right, maxPercentDelta, err);
545
    }
546

                            
                        
547
    function assertApproxEqRelDecimal(
548
        uint256 left,
549
        uint256 right,
550
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
551
        uint256 decimals
552
    ) internal pure virtual {
553
        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
554
    }
555

                            
                        
556
    function assertApproxEqRelDecimal(
557
        uint256 left,
558
        uint256 right,
559
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
560
        uint256 decimals,
561
        string memory err
562
    ) internal pure virtual {
563
        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
564
    }
565

                            
                        
566
    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual {
567
        vm.assertApproxEqRel(left, right, maxPercentDelta);
568
    }
569

                            
                        
570
    function assertApproxEqRel(
571
        int256 left,
572
        int256 right,
573
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
574
        string memory err
575
    ) internal pure virtual {
576
        vm.assertApproxEqRel(left, right, maxPercentDelta, err);
577
    }
578

                            
                        
579
    function assertApproxEqRelDecimal(
580
        int256 left,
581
        int256 right,
582
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
583
        uint256 decimals
584
    ) internal pure virtual {
585
        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
586
    }
587

                            
                        
588
    function assertApproxEqRelDecimal(
589
        int256 left,
590
        int256 right,
591
        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
592
        uint256 decimals,
593
        string memory err
594
    ) internal pure virtual {
595
        vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
596
    }
597

                            
                        
598
    // Inherited from DSTest, not used but kept for backwards-compatibility
599
    function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) {
600
        return keccak256(left) == keccak256(right);
601
    }
602

                            
                        
603
    function assertEq0(bytes memory left, bytes memory right) internal pure virtual {
604
        assertEq(left, right);
605
    }
606

                            
                        
607
    function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
608
        assertEq(left, right, err);
609
    }
610

                            
                        
611
    function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual {
612
        assertNotEq(left, right);
613
    }
614

                            
                        
615
    function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
616
        assertNotEq(left, right, err);
617
    }
618

                            
                        
619
    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
620
        assertEqCall(target, callDataA, target, callDataB, true);
621
    }
622

                            
                        
623
    function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
624
        internal
625
        virtual
626
    {
627
        assertEqCall(targetA, callDataA, targetB, callDataB, true);
628
    }
629

                            
                        
630
    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
631
        internal
632
        virtual
633
    {
634
        assertEqCall(target, callDataA, target, callDataB, strictRevertData);
635
    }
636

                            
                        
637
    function assertEqCall(
638
        address targetA,
639
        bytes memory callDataA,
640
        address targetB,
641
        bytes memory callDataB,
642
        bool strictRevertData
643
    ) internal virtual {
644
        (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
645
        (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
646

                            
                        
647
        if (successA && successB) {
648
            assertEq(returnDataA, returnDataB, "Call return data does not match");
649
        }
650

                            
                        
651
        if (!successA && !successB && strictRevertData) {
652
            assertEq(returnDataA, returnDataB, "Call revert data does not match");
653
        }
654

                            
                        
655
        if (!successA && successB) {
656
            emit log("Error: Calls were not equal");
657
            emit log_named_bytes("  Left call revert data", returnDataA);
658
            emit log_named_bytes(" Right call return data", returnDataB);
659
            revert("assertion failed");
660
        }
661

                            
                        
662
        if (successA && !successB) {
663
            emit log("Error: Calls were not equal");
664
            emit log_named_bytes("  Left call return data", returnDataA);
665
            emit log_named_bytes(" Right call revert data", returnDataB);
666
            revert("assertion failed");
667
        }
668
    }
669
}
670

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
import {VmSafe} from "./Vm.sol";
5

                            
                        
6
/**
7
 * StdChains provides information about EVM compatible chains that can be used in scripts/tests.
8
 * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
9
 * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
10
 * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
11
 * alias used in this contract, which can be found as the first argument to the
12
 * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.
13
 *
14
 * There are two main ways to use this contract:
15
 *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
16
 *      `setChain(string memory chainAlias, Chain memory chain)`
17
 *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
18
 *
19
 * The first time either of those are used, chains are initialized with the default set of RPC URLs.
20
 * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
21
 * `defaultRpcUrls`.
22
 *
23
 * The `setChain` function is straightforward, and it simply saves off the given chain data.
24
 *
25
 * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
26
 * we want to retrieve the RPC URL for `mainnet`:
27
 *   - If you have specified data with `setChain`, it will return that.
28
 *   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
29
 *     is valid (e.g. a URL is specified, or an environment variable is given and exists).
30
 *   - If neither of the above conditions is met, the default data is returned.
31
 *
32
 * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
33
 */
34
abstract contract StdChains {
35
    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
36

                            
                        
37
    bool private stdChainsInitialized;
38

                            
                        
39
    struct ChainData {
40
        string name;
41
        uint256 chainId;
42
        string rpcUrl;
43
    }
44

                            
                        
45
    struct Chain {
46
        // The chain name.
47
        string name;
48
        // The chain's Chain ID.
49
        uint256 chainId;
50
        // The chain's alias. (i.e. what gets specified in `foundry.toml`).
51
        string chainAlias;
52
        // A default RPC endpoint for this chain.
53
        // NOTE: This default RPC URL is included for convenience to facilitate quick tests and
54
        // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
55
        // usage as you will be throttled and this is a disservice to others who need this endpoint.
56
        string rpcUrl;
57
    }
58

                            
                        
59
    // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
60
    mapping(string => Chain) private chains;
61
    // Maps from the chain's alias to it's default RPC URL.
62
    mapping(string => string) private defaultRpcUrls;
63
    // Maps from a chain ID to it's alias.
64
    mapping(uint256 => string) private idToAlias;
65

                            
                        
66
    bool private fallbackToDefaultRpcUrls = true;
67

                            
                        
68
    // The RPC URL will be fetched from config or defaultRpcUrls if possible.
69
    function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
70
        require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
71

                            
                        
72
        initializeStdChains();
73
        chain = chains[chainAlias];
74
        require(
75
            chain.chainId != 0,
76
            string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
77
        );
78

                            
                        
79
        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
80
    }
81

                            
                        
82
    function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
83
        require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
84
        initializeStdChains();
85
        string memory chainAlias = idToAlias[chainId];
86

                            
                        
87
        chain = chains[chainAlias];
88

                            
                        
89
        require(
90
            chain.chainId != 0,
91
            string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
92
        );
93

                            
                        
94
        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
95
    }
96

                            
                        
97
    // set chain info, with priority to argument's rpcUrl field.
98
    function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
99
        require(
100
            bytes(chainAlias).length != 0,
101
            "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
102
        );
103

                            
                        
104
        require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
105

                            
                        
106
        initializeStdChains();
107
        string memory foundAlias = idToAlias[chain.chainId];
108

                            
                        
109
        require(
110
            bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
111
            string(
112
                abi.encodePacked(
113
                    "StdChains setChain(string,ChainData): Chain ID ",
114
                    vm.toString(chain.chainId),
115
                    " already used by \"",
116
                    foundAlias,
117
                    "\"."
118
                )
119
            )
120
        );
121

                            
                        
122
        uint256 oldChainId = chains[chainAlias].chainId;
123
        delete idToAlias[oldChainId];
124

                            
                        
125
        chains[chainAlias] =
126
            Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
127
        idToAlias[chain.chainId] = chainAlias;
128
    }
129

                            
                        
130
    // set chain info, with priority to argument's rpcUrl field.
131
    function setChain(string memory chainAlias, Chain memory chain) internal virtual {
132
        setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
133
    }
134

                            
                        
135
    function _toUpper(string memory str) private pure returns (string memory) {
136
        bytes memory strb = bytes(str);
137
        bytes memory copy = new bytes(strb.length);
138
        for (uint256 i = 0; i < strb.length; i++) {
139
            bytes1 b = strb[i];
140
            if (b >= 0x61 && b <= 0x7A) {
141
                copy[i] = bytes1(uint8(b) - 32);
142
            } else {
143
                copy[i] = b;
144
            }
145
        }
146
        return string(copy);
147
    }
148

                            
                        
149
    // lookup rpcUrl, in descending order of priority:
150
    // current -> config (foundry.toml) -> environment variable -> default
151
    function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)
152
        private
153
        view
154
        returns (Chain memory)
155
    {
156
        if (bytes(chain.rpcUrl).length == 0) {
157
            try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
158
                chain.rpcUrl = configRpcUrl;
159
            } catch (bytes memory err) {
160
                string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
161
                if (fallbackToDefaultRpcUrls) {
162
                    chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
163
                } else {
164
                    chain.rpcUrl = vm.envString(envName);
165
                }
166
                // Distinguish 'not found' from 'cannot read'
167
                // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
168
                bytes memory oldNotFoundError =
169
                    abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
170
                bytes memory newNotFoundError = abi.encodeWithSignature(
171
                    "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
172
                );
173
                bytes32 errHash = keccak256(err);
174
                if (
175
                    (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
176
                        || bytes(chain.rpcUrl).length == 0
177
                ) {
178
                    /// @solidity memory-safe-assembly
179
                    assembly {
180
                        revert(add(32, err), mload(err))
181
                    }
182
                }
183
            }
184
        }
185
        return chain;
186
    }
187

                            
                        
188
    function setFallbackToDefaultRpcUrls(bool useDefault) internal {
189
        fallbackToDefaultRpcUrls = useDefault;
190
    }
191

                            
                        
192
    function initializeStdChains() private {
193
        if (stdChainsInitialized) return;
194

                            
                        
195
        stdChainsInitialized = true;
196

                            
                        
197
        // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`
198
        setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
199
        setChainWithDefaultRpcUrl(
200
            "mainnet", ChainData("Mainnet", 1, "https://eth-mainnet.alchemyapi.io/v2/pwc5rmJhrdoaSEfimoKEmsvOjKSmPDrP")
201
        );
202
        setChainWithDefaultRpcUrl(
203
            "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
204
        );
205
        setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));
206
        setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
207
        setChainWithDefaultRpcUrl(
208
            "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")
209
        );
210
        setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
211
        setChainWithDefaultRpcUrl(
212
            "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")
213
        );
214
        setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
215
        setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
216
        setChainWithDefaultRpcUrl(
217
            "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")
218
        );
219
        setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
220
        setChainWithDefaultRpcUrl(
221
            "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
222
        );
223
        setChainWithDefaultRpcUrl(
224
            "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
225
        );
226
        setChainWithDefaultRpcUrl(
227
            "bnb_smart_chain_testnet",
228
            ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
229
        );
230
        setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
231
        setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
232
        setChainWithDefaultRpcUrl(
233
            "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
234
        );
235
        setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
236
        setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));
237
        setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
238
        setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));
239
        setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));
240
        setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));
241
        setChainWithDefaultRpcUrl(
242
            "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")
243
        );
244
        setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));
245
        setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com"));
246
        setChainWithDefaultRpcUrl(
247
            "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")
248
        );
249
        setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));
250
        setChainWithDefaultRpcUrl(
251
            "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")
252
        );
253
    }
254

                            
                        
255
    // set chain info, with priority to chainAlias' rpc url in foundry.toml
256
    function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
257
        string memory rpcUrl = chain.rpcUrl;
258
        defaultRpcUrls[chainAlias] = rpcUrl;
259
        chain.rpcUrl = "";
260
        setChain(chainAlias, chain);
261
        chain.rpcUrl = rpcUrl; // restore argument
262
    }
263
}
264

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
import {StdStorage, stdStorage} from "./StdStorage.sol";
7
import {console2} from "./console2.sol";
8
import {Vm} from "./Vm.sol";
9

                            
                        
10
abstract contract StdCheatsSafe {
11
    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
12

                            
                        
13
    uint256 private constant UINT256_MAX =
14
        115792089237316195423570985008687907853269984665640564039457584007913129639935;
15

                            
                        
16
    bool private gasMeteringOff;
17

                            
                        
18
    // Data structures to parse Transaction objects from the broadcast artifact
19
    // that conform to EIP1559. The Raw structs is what is parsed from the JSON
20
    // and then converted to the one that is used by the user for better UX.
21

                            
                        
22
    struct RawTx1559 {
23
        string[] arguments;
24
        address contractAddress;
25
        string contractName;
26
        // json value name = function
27
        string functionSig;
28
        bytes32 hash;
29
        // json value name = tx
30
        RawTx1559Detail txDetail;
31
        // json value name = type
32
        string opcode;
33
    }
34

                            
                        
35
    struct RawTx1559Detail {
36
        AccessList[] accessList;
37
        bytes data;
38
        address from;
39
        bytes gas;
40
        bytes nonce;
41
        address to;
42
        bytes txType;
43
        bytes value;
44
    }
45

                            
                        
46
    struct Tx1559 {
47
        string[] arguments;
48
        address contractAddress;
49
        string contractName;
50
        string functionSig;
51
        bytes32 hash;
52
        Tx1559Detail txDetail;
53
        string opcode;
54
    }
55

                            
                        
56
    struct Tx1559Detail {
57
        AccessList[] accessList;
58
        bytes data;
59
        address from;
60
        uint256 gas;
61
        uint256 nonce;
62
        address to;
63
        uint256 txType;
64
        uint256 value;
65
    }
66

                            
                        
67
    // Data structures to parse Transaction objects from the broadcast artifact
68
    // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON
69
    // and then converted to the one that is used by the user for better UX.
70

                            
                        
71
    struct TxLegacy {
72
        string[] arguments;
73
        address contractAddress;
74
        string contractName;
75
        string functionSig;
76
        string hash;
77
        string opcode;
78
        TxDetailLegacy transaction;
79
    }
80

                            
                        
81
    struct TxDetailLegacy {
82
        AccessList[] accessList;
83
        uint256 chainId;
84
        bytes data;
85
        address from;
86
        uint256 gas;
87
        uint256 gasPrice;
88
        bytes32 hash;
89
        uint256 nonce;
90
        bytes1 opcode;
91
        bytes32 r;
92
        bytes32 s;
93
        uint256 txType;
94
        address to;
95
        uint8 v;
96
        uint256 value;
97
    }
98

                            
                        
99
    struct AccessList {
100
        address accessAddress;
101
        bytes32[] storageKeys;
102
    }
103

                            
                        
104
    // Data structures to parse Receipt objects from the broadcast artifact.
105
    // The Raw structs is what is parsed from the JSON
106
    // and then converted to the one that is used by the user for better UX.
107

                            
                        
108
    struct RawReceipt {
109
        bytes32 blockHash;
110
        bytes blockNumber;
111
        address contractAddress;
112
        bytes cumulativeGasUsed;
113
        bytes effectiveGasPrice;
114
        address from;
115
        bytes gasUsed;
116
        RawReceiptLog[] logs;
117
        bytes logsBloom;
118
        bytes status;
119
        address to;
120
        bytes32 transactionHash;
121
        bytes transactionIndex;
122
    }
123

                            
                        
124
    struct Receipt {
125
        bytes32 blockHash;
126
        uint256 blockNumber;
127
        address contractAddress;
128
        uint256 cumulativeGasUsed;
129
        uint256 effectiveGasPrice;
130
        address from;
131
        uint256 gasUsed;
132
        ReceiptLog[] logs;
133
        bytes logsBloom;
134
        uint256 status;
135
        address to;
136
        bytes32 transactionHash;
137
        uint256 transactionIndex;
138
    }
139

                            
                        
140
    // Data structures to parse the entire broadcast artifact, assuming the
141
    // transactions conform to EIP1559.
142

                            
                        
143
    struct EIP1559ScriptArtifact {
144
        string[] libraries;
145
        string path;
146
        string[] pending;
147
        Receipt[] receipts;
148
        uint256 timestamp;
149
        Tx1559[] transactions;
150
        TxReturn[] txReturns;
151
    }
152

                            
                        
153
    struct RawEIP1559ScriptArtifact {
154
        string[] libraries;
155
        string path;
156
        string[] pending;
157
        RawReceipt[] receipts;
158
        TxReturn[] txReturns;
159
        uint256 timestamp;
160
        RawTx1559[] transactions;
161
    }
162

                            
                        
163
    struct RawReceiptLog {
164
        // json value = address
165
        address logAddress;
166
        bytes32 blockHash;
167
        bytes blockNumber;
168
        bytes data;
169
        bytes logIndex;
170
        bool removed;
171
        bytes32[] topics;
172
        bytes32 transactionHash;
173
        bytes transactionIndex;
174
        bytes transactionLogIndex;
175
    }
176

                            
                        
177
    struct ReceiptLog {
178
        // json value = address
179
        address logAddress;
180
        bytes32 blockHash;
181
        uint256 blockNumber;
182
        bytes data;
183
        uint256 logIndex;
184
        bytes32[] topics;
185
        uint256 transactionIndex;
186
        uint256 transactionLogIndex;
187
        bool removed;
188
    }
189

                            
                        
190
    struct TxReturn {
191
        string internalType;
192
        string value;
193
    }
194

                            
                        
195
    struct Account {
196
        address addr;
197
        uint256 key;
198
    }
199

                            
                        
200
    enum AddressType {
201
        Payable,
202
        NonPayable,
203
        ZeroAddress,
204
        Precompile,
205
        ForgeAddress
206
    }
207

                            
                        
208
    // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
209
    function assumeNotBlacklisted(address token, address addr) internal view virtual {
210
        // Nothing to check if `token` is not a contract.
211
        uint256 tokenCodeSize;
212
        assembly {
213
            tokenCodeSize := extcodesize(token)
214
        }
215
        require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
216

                            
                        
217
        bool success;
218
        bytes memory returnData;
219

                            
                        
220
        // 4-byte selector for `isBlacklisted(address)`, used by USDC.
221
        (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
222
        vm.assume(!success || abi.decode(returnData, (bool)) == false);
223

                            
                        
224
        // 4-byte selector for `isBlackListed(address)`, used by USDT.
225
        (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
226
        vm.assume(!success || abi.decode(returnData, (bool)) == false);
227
    }
228

                            
                        
229
    // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
230
    // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for
231
    // backwards compatibility, since this name was used in the original PR which already has
232
    // a release. This function can be removed in a future release once we want a breaking change.
233
    function assumeNoBlacklisted(address token, address addr) internal view virtual {
234
        assumeNotBlacklisted(token, addr);
235
    }
236

                            
                        
237
    function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
238
        if (addressType == AddressType.Payable) {
239
            assumeNotPayable(addr);
240
        } else if (addressType == AddressType.NonPayable) {
241
            assumePayable(addr);
242
        } else if (addressType == AddressType.ZeroAddress) {
243
            assumeNotZeroAddress(addr);
244
        } else if (addressType == AddressType.Precompile) {
245
            assumeNotPrecompile(addr);
246
        } else if (addressType == AddressType.ForgeAddress) {
247
            assumeNotForgeAddress(addr);
248
        }
249
    }
250

                            
                        
251
    function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
252
        assumeAddressIsNot(addr, addressType1);
253
        assumeAddressIsNot(addr, addressType2);
254
    }
255

                            
                        
256
    function assumeAddressIsNot(
257
        address addr,
258
        AddressType addressType1,
259
        AddressType addressType2,
260
        AddressType addressType3
261
    ) internal virtual {
262
        assumeAddressIsNot(addr, addressType1);
263
        assumeAddressIsNot(addr, addressType2);
264
        assumeAddressIsNot(addr, addressType3);
265
    }
266

                            
                        
267
    function assumeAddressIsNot(
268
        address addr,
269
        AddressType addressType1,
270
        AddressType addressType2,
271
        AddressType addressType3,
272
        AddressType addressType4
273
    ) internal virtual {
274
        assumeAddressIsNot(addr, addressType1);
275
        assumeAddressIsNot(addr, addressType2);
276
        assumeAddressIsNot(addr, addressType3);
277
        assumeAddressIsNot(addr, addressType4);
278
    }
279

                            
                        
280
    // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
281
    // `addr` and checking the `success` return value.
282
    // NOTE: This function may result in state changes depending on the fallback/receive logic
283
    // implemented by `addr`, which should be taken into account when this function is used.
284
    function _isPayable(address addr) private returns (bool) {
285
        require(
286
            addr.balance < UINT256_MAX,
287
            "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
288
        );
289
        uint256 origBalanceTest = address(this).balance;
290
        uint256 origBalanceAddr = address(addr).balance;
291

                            
                        
292
        vm.deal(address(this), 1);
293
        (bool success,) = payable(addr).call{value: 1}("");
294

                            
                        
295
        // reset balances
296
        vm.deal(address(this), origBalanceTest);
297
        vm.deal(addr, origBalanceAddr);
298

                            
                        
299
        return success;
300
    }
301

                            
                        
302
    // NOTE: This function may result in state changes depending on the fallback/receive logic
303
    // implemented by `addr`, which should be taken into account when this function is used. See the
304
    // `_isPayable` method for more information.
305
    function assumePayable(address addr) internal virtual {
306
        vm.assume(_isPayable(addr));
307
    }
308

                            
                        
309
    function assumeNotPayable(address addr) internal virtual {
310
        vm.assume(!_isPayable(addr));
311
    }
312

                            
                        
313
    function assumeNotZeroAddress(address addr) internal pure virtual {
314
        vm.assume(addr != address(0));
315
    }
316

                            
                        
317
    function assumeNotPrecompile(address addr) internal pure virtual {
318
        assumeNotPrecompile(addr, _pureChainId());
319
    }
320

                            
                        
321
    function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
322
        // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
323
        // address), but the same rationale for excluding them applies so we include those too.
324

                            
                        
325
        // These are reserved by Ethereum and may be on all EVM-compatible chains.
326
        vm.assume(addr < address(0x1) || addr > address(0xff));
327

                            
                        
328
        // forgefmt: disable-start
329
        if (chainId == 10 || chainId == 420) {
330
            // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
331
            vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
332
        } else if (chainId == 42161 || chainId == 421613) {
333
            // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
334
            vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
335
        } else if (chainId == 43114 || chainId == 43113) {
336
            // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
337
            vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
338
            vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
339
            vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
340
        }
341
        // forgefmt: disable-end
342
    }
343

                            
                        
344
    function assumeNotForgeAddress(address addr) internal pure virtual {
345
        // vm, console, and Create2Deployer addresses
346
        vm.assume(
347
            addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
348
                && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
349
        );
350
    }
351

                            
                        
352
    function readEIP1559ScriptArtifact(string memory path)
353
        internal
354
        view
355
        virtual
356
        returns (EIP1559ScriptArtifact memory)
357
    {
358
        string memory data = vm.readFile(path);
359
        bytes memory parsedData = vm.parseJson(data);
360
        RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
361
        EIP1559ScriptArtifact memory artifact;
362
        artifact.libraries = rawArtifact.libraries;
363
        artifact.path = rawArtifact.path;
364
        artifact.timestamp = rawArtifact.timestamp;
365
        artifact.pending = rawArtifact.pending;
366
        artifact.txReturns = rawArtifact.txReturns;
367
        artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
368
        artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
369
        return artifact;
370
    }
371

                            
                        
372
    function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
373
        Tx1559[] memory txs = new Tx1559[](rawTxs.length);
374
        for (uint256 i; i < rawTxs.length; i++) {
375
            txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
376
        }
377
        return txs;
378
    }
379

                            
                        
380
    function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
381
        Tx1559 memory transaction;
382
        transaction.arguments = rawTx.arguments;
383
        transaction.contractName = rawTx.contractName;
384
        transaction.functionSig = rawTx.functionSig;
385
        transaction.hash = rawTx.hash;
386
        transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
387
        transaction.opcode = rawTx.opcode;
388
        return transaction;
389
    }
390

                            
                        
391
    function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
392
        internal
393
        pure
394
        virtual
395
        returns (Tx1559Detail memory)
396
    {
397
        Tx1559Detail memory txDetail;
398
        txDetail.data = rawDetail.data;
399
        txDetail.from = rawDetail.from;
400
        txDetail.to = rawDetail.to;
401
        txDetail.nonce = _bytesToUint(rawDetail.nonce);
402
        txDetail.txType = _bytesToUint(rawDetail.txType);
403
        txDetail.value = _bytesToUint(rawDetail.value);
404
        txDetail.gas = _bytesToUint(rawDetail.gas);
405
        txDetail.accessList = rawDetail.accessList;
406
        return txDetail;
407
    }
408

                            
                        
409
    function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
410
        string memory deployData = vm.readFile(path);
411
        bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
412
        RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
413
        return rawToConvertedEIPTx1559s(rawTxs);
414
    }
415

                            
                        
416
    function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
417
        string memory deployData = vm.readFile(path);
418
        string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
419
        bytes memory parsedDeployData = vm.parseJson(deployData, key);
420
        RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
421
        return rawToConvertedEIPTx1559(rawTx);
422
    }
423

                            
                        
424
    // Analogous to readTransactions, but for receipts.
425
    function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
426
        string memory deployData = vm.readFile(path);
427
        bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
428
        RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
429
        return rawToConvertedReceipts(rawReceipts);
430
    }
431

                            
                        
432
    function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
433
        string memory deployData = vm.readFile(path);
434
        string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
435
        bytes memory parsedDeployData = vm.parseJson(deployData, key);
436
        RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
437
        return rawToConvertedReceipt(rawReceipt);
438
    }
439

                            
                        
440
    function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
441
        Receipt[] memory receipts = new Receipt[](rawReceipts.length);
442
        for (uint256 i; i < rawReceipts.length; i++) {
443
            receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
444
        }
445
        return receipts;
446
    }
447

                            
                        
448
    function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
449
        Receipt memory receipt;
450
        receipt.blockHash = rawReceipt.blockHash;
451
        receipt.to = rawReceipt.to;
452
        receipt.from = rawReceipt.from;
453
        receipt.contractAddress = rawReceipt.contractAddress;
454
        receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
455
        receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
456
        receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
457
        receipt.status = _bytesToUint(rawReceipt.status);
458
        receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
459
        receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
460
        receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
461
        receipt.logsBloom = rawReceipt.logsBloom;
462
        receipt.transactionHash = rawReceipt.transactionHash;
463
        return receipt;
464
    }
465

                            
                        
466
    function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
467
        internal
468
        pure
469
        virtual
470
        returns (ReceiptLog[] memory)
471
    {
472
        ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
473
        for (uint256 i; i < rawLogs.length; i++) {
474
            logs[i].logAddress = rawLogs[i].logAddress;
475
            logs[i].blockHash = rawLogs[i].blockHash;
476
            logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
477
            logs[i].data = rawLogs[i].data;
478
            logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
479
            logs[i].topics = rawLogs[i].topics;
480
            logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
481
            logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
482
            logs[i].removed = rawLogs[i].removed;
483
        }
484
        return logs;
485
    }
486

                            
                        
487
    // Deploy a contract by fetching the contract bytecode from
488
    // the artifacts directory
489
    // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`
490
    function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
491
        bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
492
        /// @solidity memory-safe-assembly
493
        assembly {
494
            addr := create(0, add(bytecode, 0x20), mload(bytecode))
495
        }
496

                            
                        
497
        require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
498
    }
499

                            
                        
500
    function deployCode(string memory what) internal virtual returns (address addr) {
501
        bytes memory bytecode = vm.getCode(what);
502
        /// @solidity memory-safe-assembly
503
        assembly {
504
            addr := create(0, add(bytecode, 0x20), mload(bytecode))
505
        }
506

                            
                        
507
        require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
508
    }
509

                            
                        
510
    /// @dev deploy contract with value on construction
511
    function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
512
        bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
513
        /// @solidity memory-safe-assembly
514
        assembly {
515
            addr := create(val, add(bytecode, 0x20), mload(bytecode))
516
        }
517

                            
                        
518
        require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
519
    }
520

                            
                        
521
    function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
522
        bytes memory bytecode = vm.getCode(what);
523
        /// @solidity memory-safe-assembly
524
        assembly {
525
            addr := create(val, add(bytecode, 0x20), mload(bytecode))
526
        }
527

                            
                        
528
        require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
529
    }
530

                            
                        
531
    // creates a labeled address and the corresponding private key
532
    function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
533
        privateKey = uint256(keccak256(abi.encodePacked(name)));
534
        addr = vm.addr(privateKey);
535
        vm.label(addr, name);
536
    }
537

                            
                        
538
    // creates a labeled address
539
    function makeAddr(string memory name) internal virtual returns (address addr) {
540
        (addr,) = makeAddrAndKey(name);
541
    }
542

                            
                        
543
    // Destroys an account immediately, sending the balance to beneficiary.
544
    // Destroying means: balance will be zero, code will be empty, and nonce will be 0
545
    // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce
546
    // only after tx ends, this will run immediately.
547
    function destroyAccount(address who, address beneficiary) internal virtual {
548
        uint256 currBalance = who.balance;
549
        vm.etch(who, abi.encode());
550
        vm.deal(who, 0);
551
        vm.resetNonce(who);
552

                            
                        
553
        uint256 beneficiaryBalance = beneficiary.balance;
554
        vm.deal(beneficiary, currBalance + beneficiaryBalance);
555
    }
556

                            
                        
557
    // creates a struct containing both a labeled address and the corresponding private key
558
    function makeAccount(string memory name) internal virtual returns (Account memory account) {
559
        (account.addr, account.key) = makeAddrAndKey(name);
560
    }
561

                            
                        
562
    function deriveRememberKey(string memory mnemonic, uint32 index)
563
        internal
564
        virtual
565
        returns (address who, uint256 privateKey)
566
    {
567
        privateKey = vm.deriveKey(mnemonic, index);
568
        who = vm.rememberKey(privateKey);
569
    }
570

                            
                        
571
    function _bytesToUint(bytes memory b) private pure returns (uint256) {
572
        require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
573
        return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
574
    }
575

                            
                        
576
    function isFork() internal view virtual returns (bool status) {
577
        try vm.activeFork() {
578
            status = true;
579
        } catch (bytes memory) {}
580
    }
581

                            
                        
582
    modifier skipWhenForking() {
583
        if (!isFork()) {
584
            _;
585
        }
586
    }
587

                            
                        
588
    modifier skipWhenNotForking() {
589
        if (isFork()) {
590
            _;
591
        }
592
    }
593

                            
                        
594
    modifier noGasMetering() {
595
        vm.pauseGasMetering();
596
        // To prevent turning gas monitoring back on with nested functions that use this modifier,
597
        // we check if gasMetering started in the off position. If it did, we don't want to turn
598
        // it back on until we exit the top level function that used the modifier
599
        //
600
        // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
601
        // funcA will have `gasStartedOff` as false, funcB will have it as true,
602
        // so we only turn metering back on at the end of the funcA
603
        bool gasStartedOff = gasMeteringOff;
604
        gasMeteringOff = true;
605

                            
                        
606
        _;
607

                            
                        
608
        // if gas metering was on when this modifier was called, turn it back on at the end
609
        if (!gasStartedOff) {
610
            gasMeteringOff = false;
611
            vm.resumeGasMetering();
612
        }
613
    }
614

                            
                        
615
    // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
616
    // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
617
    // can't simply access the chain ID in a normal view or pure function because the solc View Pure
618
    // Checker changed `chainid` from pure to view in 0.8.0.
619
    function _viewChainId() private view returns (uint256 chainId) {
620
        // Assembly required since `block.chainid` was introduced in 0.8.0.
621
        assembly {
622
            chainId := chainid()
623
        }
624

                            
                        
625
        address(this); // Silence warnings in older Solc versions.
626
    }
627

                            
                        
628
    function _pureChainId() private pure returns (uint256 chainId) {
629
        function() internal view returns (uint256) fnIn = _viewChainId;
630
        function() internal pure returns (uint256) pureChainId;
631
        assembly {
632
            pureChainId := fnIn
633
        }
634
        chainId = pureChainId();
635
    }
636
}
637

                            
                        
638
// Wrappers around cheatcodes to avoid footguns
639
abstract contract StdCheats is StdCheatsSafe {
640
    using stdStorage for StdStorage;
641

                            
                        
642
    StdStorage private stdstore;
643
    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
644
    address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
645

                            
                        
646
    // Skip forward or rewind time by the specified number of seconds
647
    function skip(uint256 time) internal virtual {
648
        vm.warp(block.timestamp + time);
649
    }
650

                            
                        
651
    function rewind(uint256 time) internal virtual {
652
        vm.warp(block.timestamp - time);
653
    }
654

                            
                        
655
    // Setup a prank from an address that has some ether
656
    function hoax(address msgSender) internal virtual {
657
        vm.deal(msgSender, 1 << 128);
658
        vm.prank(msgSender);
659
    }
660

                            
                        
661
    function hoax(address msgSender, uint256 give) internal virtual {
662
        vm.deal(msgSender, give);
663
        vm.prank(msgSender);
664
    }
665

                            
                        
666
    function hoax(address msgSender, address origin) internal virtual {
667
        vm.deal(msgSender, 1 << 128);
668
        vm.prank(msgSender, origin);
669
    }
670

                            
                        
671
    function hoax(address msgSender, address origin, uint256 give) internal virtual {
672
        vm.deal(msgSender, give);
673
        vm.prank(msgSender, origin);
674
    }
675

                            
                        
676
    // Start perpetual prank from an address that has some ether
677
    function startHoax(address msgSender) internal virtual {
678
        vm.deal(msgSender, 1 << 128);
679
        vm.startPrank(msgSender);
680
    }
681

                            
                        
682
    function startHoax(address msgSender, uint256 give) internal virtual {
683
        vm.deal(msgSender, give);
684
        vm.startPrank(msgSender);
685
    }
686

                            
                        
687
    // Start perpetual prank from an address that has some ether
688
    // tx.origin is set to the origin parameter
689
    function startHoax(address msgSender, address origin) internal virtual {
690
        vm.deal(msgSender, 1 << 128);
691
        vm.startPrank(msgSender, origin);
692
    }
693

                            
                        
694
    function startHoax(address msgSender, address origin, uint256 give) internal virtual {
695
        vm.deal(msgSender, give);
696
        vm.startPrank(msgSender, origin);
697
    }
698

                            
                        
699
    function changePrank(address msgSender) internal virtual {
700
        console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
701
        vm.stopPrank();
702
        vm.startPrank(msgSender);
703
    }
704

                            
                        
705
    function changePrank(address msgSender, address txOrigin) internal virtual {
706
        vm.stopPrank();
707
        vm.startPrank(msgSender, txOrigin);
708
    }
709

                            
                        
710
    // The same as Vm's `deal`
711
    // Use the alternative signature for ERC20 tokens
712
    function deal(address to, uint256 give) internal virtual {
713
        vm.deal(to, give);
714
    }
715

                            
                        
716
    // Set the balance of an account for any ERC20 token
717
    // Use the alternative signature to update `totalSupply`
718
    function deal(address token, address to, uint256 give) internal virtual {
719
        deal(token, to, give, false);
720
    }
721

                            
                        
722
    // Set the balance of an account for any ERC1155 token
723
    // Use the alternative signature to update `totalSupply`
724
    function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
725
        dealERC1155(token, to, id, give, false);
726
    }
727

                            
                        
728
    function deal(address token, address to, uint256 give, bool adjust) internal virtual {
729
        // get current balance
730
        (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
731
        uint256 prevBal = abi.decode(balData, (uint256));
732

                            
                        
733
        // update balance
734
        stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
735

                            
                        
736
        // update total supply
737
        if (adjust) {
738
            (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
739
            uint256 totSup = abi.decode(totSupData, (uint256));
740
            if (give < prevBal) {
741
                totSup -= (prevBal - give);
742
            } else {
743
                totSup += (give - prevBal);
744
            }
745
            stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
746
        }
747
    }
748

                            
                        
749
    function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
750
        // get current balance
751
        (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
752
        uint256 prevBal = abi.decode(balData, (uint256));
753

                            
                        
754
        // update balance
755
        stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
756

                            
                        
757
        // update total supply
758
        if (adjust) {
759
            (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
760
            require(
761
                totSupData.length != 0,
762
                "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply."
763
            );
764
            uint256 totSup = abi.decode(totSupData, (uint256));
765
            if (give < prevBal) {
766
                totSup -= (prevBal - give);
767
            } else {
768
                totSup += (give - prevBal);
769
            }
770
            stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
771
        }
772
    }
773

                            
                        
774
    function dealERC721(address token, address to, uint256 id) internal virtual {
775
        // check if token id is already minted and the actual owner.
776
        (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
777
        require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted.");
778

                            
                        
779
        // get owner current balance
780
        (, bytes memory fromBalData) =
781
            token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
782
        uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
783

                            
                        
784
        // get new user current balance
785
        (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
786
        uint256 toPrevBal = abi.decode(toBalData, (uint256));
787

                            
                        
788
        // update balances
789
        stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
790
        stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
791

                            
                        
792
        // update owner
793
        stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
794
    }
795

                            
                        
796
    function deployCodeTo(string memory what, address where) internal virtual {
797
        deployCodeTo(what, "", 0, where);
798
    }
799

                            
                        
800
    function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
801
        deployCodeTo(what, args, 0, where);
802
    }
803

                            
                        
804
    function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
805
        bytes memory creationCode = vm.getCode(what);
806
        vm.etch(where, abi.encodePacked(creationCode, args));
807
        (bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
808
        require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
809
        vm.etch(where, runtimeBytecode);
810
    }
811

                            
                        
812
    // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
813
    function console2_log_StdCheats(string memory p0) private view {
814
        (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
815
        status;
816
    }
817
}
818

                            
                        

Lines covered: 0 / 10 (0.0%)

1
// SPDX-License-Identifier: MIT
2
// Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
3
pragma solidity >=0.6.2 <0.9.0;
4

                            
                        
5
library stdError {
6
    bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
7
    bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
8
    bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
9
    bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
10
    bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
11
    bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
12
    bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
13
    bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
14
    bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
15
}
16

                            
                        

Lines covered: 0 / 20 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
abstract contract StdInvariant {
7
    struct FuzzSelector {
8
        address addr;
9
        bytes4[] selectors;
10
    }
11

                            
                        
12
    struct FuzzArtifactSelector {
13
        string artifact;
14
        bytes4[] selectors;
15
    }
16

                            
                        
17
    struct FuzzInterface {
18
        address addr;
19
        string[] artifacts;
20
    }
21

                            
                        
22
    address[] private _excludedContracts;
23
    address[] private _excludedSenders;
24
    address[] private _targetedContracts;
25
    address[] private _targetedSenders;
26

                            
                        
27
    string[] private _excludedArtifacts;
28
    string[] private _targetedArtifacts;
29

                            
                        
30
    FuzzArtifactSelector[] private _targetedArtifactSelectors;
31

                            
                        
32
    FuzzSelector[] private _excludedSelectors;
33
    FuzzSelector[] private _targetedSelectors;
34

                            
                        
35
    FuzzInterface[] private _targetedInterfaces;
36

                            
                        
37
    // Functions for users:
38
    // These are intended to be called in tests.
39

                            
                        
40
    function excludeContract(address newExcludedContract_) internal {
41
        _excludedContracts.push(newExcludedContract_);
42
    }
43

                            
                        
44
    function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
45
        _excludedSelectors.push(newExcludedSelector_);
46
    }
47

                            
                        
48
    function excludeSender(address newExcludedSender_) internal {
49
        _excludedSenders.push(newExcludedSender_);
50
    }
51

                            
                        
52
    function excludeArtifact(string memory newExcludedArtifact_) internal {
53
        _excludedArtifacts.push(newExcludedArtifact_);
54
    }
55

                            
                        
56
    function targetArtifact(string memory newTargetedArtifact_) internal {
57
        _targetedArtifacts.push(newTargetedArtifact_);
58
    }
59

                            
                        
60
    function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
61
        _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
62
    }
63

                            
                        
64
    function targetContract(address newTargetedContract_) internal {
65
        _targetedContracts.push(newTargetedContract_);
66
    }
67

                            
                        
68
    function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
69
        _targetedSelectors.push(newTargetedSelector_);
70
    }
71

                            
                        
72
    function targetSender(address newTargetedSender_) internal {
73
        _targetedSenders.push(newTargetedSender_);
74
    }
75

                            
                        
76
    function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
77
        _targetedInterfaces.push(newTargetedInterface_);
78
    }
79

                            
                        
80
    // Functions for forge:
81
    // These are called by forge to run invariant tests and don't need to be called in tests.
82

                            
                        
83
    function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
84
        excludedArtifacts_ = _excludedArtifacts;
85
    }
86

                            
                        
87
    function excludeContracts() public view returns (address[] memory excludedContracts_) {
88
        excludedContracts_ = _excludedContracts;
89
    }
90

                            
                        
91
    function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
92
        excludedSelectors_ = _excludedSelectors;
93
    }
94

                            
                        
95
    function excludeSenders() public view returns (address[] memory excludedSenders_) {
96
        excludedSenders_ = _excludedSenders;
97
    }
98

                            
                        
99
    function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
100
        targetedArtifacts_ = _targetedArtifacts;
101
    }
102

                            
                        
103
    function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
104
        targetedArtifactSelectors_ = _targetedArtifactSelectors;
105
    }
106

                            
                        
107
    function targetContracts() public view returns (address[] memory targetedContracts_) {
108
        targetedContracts_ = _targetedContracts;
109
    }
110

                            
                        
111
    function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
112
        targetedSelectors_ = _targetedSelectors;
113
    }
114

                            
                        
115
    function targetSenders() public view returns (address[] memory targetedSenders_) {
116
        targetedSenders_ = _targetedSenders;
117
    }
118

                            
                        
119
    function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
120
        targetedInterfaces_ = _targetedInterfaces;
121
    }
122
}
123

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.0 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
import {VmSafe} from "./Vm.sol";
7

                            
                        
8
// Helpers for parsing and writing JSON files
9
// To parse:
10
// ```
11
// using stdJson for string;
12
// string memory json = vm.readFile("<some_path>");
13
// json.readUint("<json_path>");
14
// ```
15
// To write:
16
// ```
17
// using stdJson for string;
18
// string memory json = "json";
19
// json.serialize("a", uint256(123));
20
// string memory semiFinal = json.serialize("b", string("test"));
21
// string memory finalJson = json.serialize("c", semiFinal);
22
// finalJson.write("<some_path>");
23
// ```
24

                            
                        
25
library stdJson {
26
    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
27

                            
                        
28
    function keyExists(string memory json, string memory key) internal view returns (bool) {
29
        return vm.keyExistsJson(json, key);
30
    }
31

                            
                        
32
    function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
33
        return vm.parseJson(json, key);
34
    }
35

                            
                        
36
    function readUint(string memory json, string memory key) internal pure returns (uint256) {
37
        return vm.parseJsonUint(json, key);
38
    }
39

                            
                        
40
    function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
41
        return vm.parseJsonUintArray(json, key);
42
    }
43

                            
                        
44
    function readInt(string memory json, string memory key) internal pure returns (int256) {
45
        return vm.parseJsonInt(json, key);
46
    }
47

                            
                        
48
    function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
49
        return vm.parseJsonIntArray(json, key);
50
    }
51

                            
                        
52
    function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
53
        return vm.parseJsonBytes32(json, key);
54
    }
55

                            
                        
56
    function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
57
        return vm.parseJsonBytes32Array(json, key);
58
    }
59

                            
                        
60
    function readString(string memory json, string memory key) internal pure returns (string memory) {
61
        return vm.parseJsonString(json, key);
62
    }
63

                            
                        
64
    function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
65
        return vm.parseJsonStringArray(json, key);
66
    }
67

                            
                        
68
    function readAddress(string memory json, string memory key) internal pure returns (address) {
69
        return vm.parseJsonAddress(json, key);
70
    }
71

                            
                        
72
    function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
73
        return vm.parseJsonAddressArray(json, key);
74
    }
75

                            
                        
76
    function readBool(string memory json, string memory key) internal pure returns (bool) {
77
        return vm.parseJsonBool(json, key);
78
    }
79

                            
                        
80
    function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
81
        return vm.parseJsonBoolArray(json, key);
82
    }
83

                            
                        
84
    function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
85
        return vm.parseJsonBytes(json, key);
86
    }
87

                            
                        
88
    function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
89
        return vm.parseJsonBytesArray(json, key);
90
    }
91

                            
                        
92
    function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
93
        return keyExists(json, key) ? readUint(json, key) : defaultValue;
94
    }
95

                            
                        
96
    function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
97
        internal
98
        view
99
        returns (uint256[] memory)
100
    {
101
        return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
102
    }
103

                            
                        
104
    function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
105
        return keyExists(json, key) ? readInt(json, key) : defaultValue;
106
    }
107

                            
                        
108
    function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
109
        internal
110
        view
111
        returns (int256[] memory)
112
    {
113
        return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
114
    }
115

                            
                        
116
    function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
117
        internal
118
        view
119
        returns (bytes32)
120
    {
121
        return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
122
    }
123

                            
                        
124
    function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
125
        internal
126
        view
127
        returns (bytes32[] memory)
128
    {
129
        return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
130
    }
131

                            
                        
132
    function readStringOr(string memory json, string memory key, string memory defaultValue)
133
        internal
134
        view
135
        returns (string memory)
136
    {
137
        return keyExists(json, key) ? readString(json, key) : defaultValue;
138
    }
139

                            
                        
140
    function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
141
        internal
142
        view
143
        returns (string[] memory)
144
    {
145
        return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
146
    }
147

                            
                        
148
    function readAddressOr(string memory json, string memory key, address defaultValue)
149
        internal
150
        view
151
        returns (address)
152
    {
153
        return keyExists(json, key) ? readAddress(json, key) : defaultValue;
154
    }
155

                            
                        
156
    function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
157
        internal
158
        view
159
        returns (address[] memory)
160
    {
161
        return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
162
    }
163

                            
                        
164
    function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
165
        return keyExists(json, key) ? readBool(json, key) : defaultValue;
166
    }
167

                            
                        
168
    function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
169
        internal
170
        view
171
        returns (bool[] memory)
172
    {
173
        return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
174
    }
175

                            
                        
176
    function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
177
        internal
178
        view
179
        returns (bytes memory)
180
    {
181
        return keyExists(json, key) ? readBytes(json, key) : defaultValue;
182
    }
183

                            
                        
184
    function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
185
        internal
186
        view
187
        returns (bytes[] memory)
188
    {
189
        return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
190
    }
191

                            
                        
192
    function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
193
        return vm.serializeJson(jsonKey, rootObject);
194
    }
195

                            
                        
196
    function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
197
        return vm.serializeBool(jsonKey, key, value);
198
    }
199

                            
                        
200
    function serialize(string memory jsonKey, string memory key, bool[] memory value)
201
        internal
202
        returns (string memory)
203
    {
204
        return vm.serializeBool(jsonKey, key, value);
205
    }
206

                            
                        
207
    function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
208
        return vm.serializeUint(jsonKey, key, value);
209
    }
210

                            
                        
211
    function serialize(string memory jsonKey, string memory key, uint256[] memory value)
212
        internal
213
        returns (string memory)
214
    {
215
        return vm.serializeUint(jsonKey, key, value);
216
    }
217

                            
                        
218
    function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
219
        return vm.serializeInt(jsonKey, key, value);
220
    }
221

                            
                        
222
    function serialize(string memory jsonKey, string memory key, int256[] memory value)
223
        internal
224
        returns (string memory)
225
    {
226
        return vm.serializeInt(jsonKey, key, value);
227
    }
228

                            
                        
229
    function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
230
        return vm.serializeAddress(jsonKey, key, value);
231
    }
232

                            
                        
233
    function serialize(string memory jsonKey, string memory key, address[] memory value)
234
        internal
235
        returns (string memory)
236
    {
237
        return vm.serializeAddress(jsonKey, key, value);
238
    }
239

                            
                        
240
    function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
241
        return vm.serializeBytes32(jsonKey, key, value);
242
    }
243

                            
                        
244
    function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
245
        internal
246
        returns (string memory)
247
    {
248
        return vm.serializeBytes32(jsonKey, key, value);
249
    }
250

                            
                        
251
    function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
252
        return vm.serializeBytes(jsonKey, key, value);
253
    }
254

                            
                        
255
    function serialize(string memory jsonKey, string memory key, bytes[] memory value)
256
        internal
257
        returns (string memory)
258
    {
259
        return vm.serializeBytes(jsonKey, key, value);
260
    }
261

                            
                        
262
    function serialize(string memory jsonKey, string memory key, string memory value)
263
        internal
264
        returns (string memory)
265
    {
266
        return vm.serializeString(jsonKey, key, value);
267
    }
268

                            
                        
269
    function serialize(string memory jsonKey, string memory key, string[] memory value)
270
        internal
271
        returns (string memory)
272
    {
273
        return vm.serializeString(jsonKey, key, value);
274
    }
275

                            
                        
276
    function write(string memory jsonKey, string memory path) internal {
277
        vm.writeJson(jsonKey, path);
278
    }
279

                            
                        
280
    function write(string memory jsonKey, string memory path, string memory valueKey) internal {
281
        vm.writeJson(jsonKey, path, valueKey);
282
    }
283
}
284

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
library stdMath {
5
    int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
6

                            
                        
7
    function abs(int256 a) internal pure returns (uint256) {
8
        // Required or it will fail when `a = type(int256).min`
9
        if (a == INT256_MIN) {
10
            return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
11
        }
12

                            
                        
13
        return uint256(a > 0 ? a : -a);
14
    }
15

                            
                        
16
    function delta(uint256 a, uint256 b) internal pure returns (uint256) {
17
        return a > b ? a - b : b - a;
18
    }
19

                            
                        
20
    function delta(int256 a, int256 b) internal pure returns (uint256) {
21
        // a and b are of the same sign
22
        // this works thanks to two's complement, the left-most bit is the sign bit
23
        if ((a ^ b) > -1) {
24
            return delta(abs(a), abs(b));
25
        }
26

                            
                        
27
        // a and b are of opposite signs
28
        return abs(a) + abs(b);
29
    }
30

                            
                        
31
    function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
32
        uint256 absDelta = delta(a, b);
33

                            
                        
34
        return absDelta * 1e18 / b;
35
    }
36

                            
                        
37
    function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
38
        uint256 absDelta = delta(a, b);
39
        uint256 absB = abs(b);
40

                            
                        
41
        return absDelta * 1e18 / absB;
42
    }
43
}
44

                            
                        

Lines covered: 0 / 2 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
import {Vm} from "./Vm.sol";
5

                            
                        
6
struct FindData {
7
    uint256 slot;
8
    uint256 offsetLeft;
9
    uint256 offsetRight;
10
    bool found;
11
}
12

                            
                        
13
struct StdStorage {
14
    mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
15
    bytes32[] _keys;
16
    bytes4 _sig;
17
    uint256 _depth;
18
    address _target;
19
    bytes32 _set;
20
    bool _enable_packed_slots;
21
    bytes _calldata;
22
}
23

                            
                        
24
library stdStorageSafe {
25
    event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
26
    event WARNING_UninitedSlot(address who, uint256 slot);
27

                            
                        
28
    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
29
    uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
30

                            
                        
31
    function sigs(string memory sigStr) internal pure returns (bytes4) {
32
        return bytes4(keccak256(bytes(sigStr)));
33
    }
34

                            
                        
35
    function getCallParams(StdStorage storage self) internal view returns (bytes memory) {
36
        if (self._calldata.length == 0) {
37
            return flatten(self._keys);
38
        } else {
39
            return self._calldata;
40
        }
41
    }
42

                            
                        
43
    // Calls target contract with configured parameters
44
    function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {
45
        bytes memory cald = abi.encodePacked(self._sig, getCallParams(self));
46
        (bool success, bytes memory rdat) = self._target.staticcall(cald);
47
        bytes32 result = bytesToBytes32(rdat, 32 * self._depth);
48

                            
                        
49
        return (success, result);
50
    }
51

                            
                        
52
    // Tries mutating slot value to determine if the targeted value is stored in it.
53
    // If current value is 0, then we are setting slot value to type(uint256).max
54
    // Otherwise, we set it to 0. That way, return value should always be affected.
55
    function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {
56
        bytes32 prevSlotValue = vm.load(self._target, slot);
57
        (bool success, bytes32 prevReturnValue) = callTarget(self);
58

                            
                        
59
        bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);
60
        vm.store(self._target, slot, testVal);
61

                            
                        
62
        (, bytes32 newReturnValue) = callTarget(self);
63

                            
                        
64
        vm.store(self._target, slot, prevSlotValue);
65

                            
                        
66
        return (success && (prevReturnValue != newReturnValue));
67
    }
68

                            
                        
69
    // Tries setting one of the bits in slot to 1 until return value changes.
70
    // Index of resulted bit is an offset packed slot has from left/right side
71
    function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {
72
        for (uint256 offset = 0; offset < 256; offset++) {
73
            uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);
74
            vm.store(self._target, slot, bytes32(valueToPut));
75

                            
                        
76
            (bool success, bytes32 data) = callTarget(self);
77

                            
                        
78
            if (success && (uint256(data) > 0)) {
79
                return (true, offset);
80
            }
81
        }
82
        return (false, 0);
83
    }
84

                            
                        
85
    function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {
86
        bytes32 prevSlotValue = vm.load(self._target, slot);
87

                            
                        
88
        (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);
89
        (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);
90

                            
                        
91
        // `findOffset` may mutate slot value, so we are setting it to initial value
92
        vm.store(self._target, slot, prevSlotValue);
93
        return (foundLeft && foundRight, offsetLeft, offsetRight);
94
    }
95

                            
                        
96
    function find(StdStorage storage self) internal returns (FindData storage) {
97
        return find(self, true);
98
    }
99

                            
                        
100
    /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
101
    // slot complexity:
102
    //  if flat, will be bytes32(uint256(uint));
103
    //  if map, will be keccak256(abi.encode(key, uint(slot)));
104
    //  if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
105
    //  if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
106
    function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {
107
        address who = self._target;
108
        bytes4 fsig = self._sig;
109
        uint256 field_depth = self._depth;
110
        bytes memory params = getCallParams(self);
111

                            
                        
112
        // calldata to test against
113
        if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
114
            if (_clear) {
115
                clear(self);
116
            }
117
            return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
118
        }
119
        vm.record();
120
        (, bytes32 callResult) = callTarget(self);
121
        (bytes32[] memory reads,) = vm.accesses(address(who));
122

                            
                        
123
        if (reads.length == 0) {
124
            revert("stdStorage find(StdStorage): No storage use detected for target.");
125
        } else {
126
            for (uint256 i = reads.length; --i >= 0;) {
127
                bytes32 prev = vm.load(who, reads[i]);
128
                if (prev == bytes32(0)) {
129
                    emit WARNING_UninitedSlot(who, uint256(reads[i]));
130
                }
131

                            
                        
132
                if (!checkSlotMutatesCall(self, reads[i])) {
133
                    continue;
134
                }
135

                            
                        
136
                (uint256 offsetLeft, uint256 offsetRight) = (0, 0);
137

                            
                        
138
                if (self._enable_packed_slots) {
139
                    bool found;
140
                    (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);
141
                    if (!found) {
142
                        continue;
143
                    }
144
                }
145

                            
                        
146
                // Check that value between found offsets is equal to the current call result
147
                uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;
148

                            
                        
149
                if (uint256(callResult) != curVal) {
150
                    continue;
151
                }
152

                            
                        
153
                emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));
154
                self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =
155
                    FindData(uint256(reads[i]), offsetLeft, offsetRight, true);
156
                break;
157
            }
158
        }
159

                            
                        
160
        require(
161
            self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,
162
            "stdStorage find(StdStorage): Slot(s) not found."
163
        );
164

                            
                        
165
        if (_clear) {
166
            clear(self);
167
        }
168
        return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
169
    }
170

                            
                        
171
    function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
172
        self._target = _target;
173
        return self;
174
    }
175

                            
                        
176
    function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
177
        self._sig = _sig;
178
        return self;
179
    }
180

                            
                        
181
    function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
182
        self._sig = sigs(_sig);
183
        return self;
184
    }
185

                            
                        
186
    function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
187
        self._calldata = _calldata;
188
        return self;
189
    }
190

                            
                        
191
    function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
192
        self._keys.push(bytes32(uint256(uint160(who))));
193
        return self;
194
    }
195

                            
                        
196
    function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
197
        self._keys.push(bytes32(amt));
198
        return self;
199
    }
200

                            
                        
201
    function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
202
        self._keys.push(key);
203
        return self;
204
    }
205

                            
                        
206
    function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
207
        self._enable_packed_slots = true;
208
        return self;
209
    }
210

                            
                        
211
    function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
212
        self._depth = _depth;
213
        return self;
214
    }
215

                            
                        
216
    function read(StdStorage storage self) private returns (bytes memory) {
217
        FindData storage data = find(self, false);
218
        uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);
219
        uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;
220
        clear(self);
221
        return abi.encode(value);
222
    }
223

                            
                        
224
    function read_bytes32(StdStorage storage self) internal returns (bytes32) {
225
        return abi.decode(read(self), (bytes32));
226
    }
227

                            
                        
228
    function read_bool(StdStorage storage self) internal returns (bool) {
229
        int256 v = read_int(self);
230
        if (v == 0) return false;
231
        if (v == 1) return true;
232
        revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
233
    }
234

                            
                        
235
    function read_address(StdStorage storage self) internal returns (address) {
236
        return abi.decode(read(self), (address));
237
    }
238

                            
                        
239
    function read_uint(StdStorage storage self) internal returns (uint256) {
240
        return abi.decode(read(self), (uint256));
241
    }
242

                            
                        
243
    function read_int(StdStorage storage self) internal returns (int256) {
244
        return abi.decode(read(self), (int256));
245
    }
246

                            
                        
247
    function parent(StdStorage storage self) internal returns (uint256, bytes32) {
248
        address who = self._target;
249
        uint256 field_depth = self._depth;
250
        vm.startMappingRecording();
251
        uint256 child = find(self, true).slot - field_depth;
252
        (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
253
        if (!found) {
254
            revert(
255
                "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
256
            );
257
        }
258
        return (uint256(parent_slot), key);
259
    }
260

                            
                        
261
    function root(StdStorage storage self) internal returns (uint256) {
262
        address who = self._target;
263
        uint256 field_depth = self._depth;
264
        vm.startMappingRecording();
265
        uint256 child = find(self, true).slot - field_depth;
266
        bool found;
267
        bytes32 root_slot;
268
        bytes32 parent_slot;
269
        (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
270
        if (!found) {
271
            revert(
272
                "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
273
            );
274
        }
275
        while (found) {
276
            root_slot = parent_slot;
277
            (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
278
        }
279
        return uint256(root_slot);
280
    }
281

                            
                        
282
    function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
283
        bytes32 out;
284

                            
                        
285
        uint256 max = b.length > 32 ? 32 : b.length;
286
        for (uint256 i = 0; i < max; i++) {
287
            out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
288
        }
289
        return out;
290
    }
291

                            
                        
292
    function flatten(bytes32[] memory b) private pure returns (bytes memory) {
293
        bytes memory result = new bytes(b.length * 32);
294
        for (uint256 i = 0; i < b.length; i++) {
295
            bytes32 k = b[i];
296
            /// @solidity memory-safe-assembly
297
            assembly {
298
                mstore(add(result, add(32, mul(32, i))), k)
299
            }
300
        }
301

                            
                        
302
        return result;
303
    }
304

                            
                        
305
    function clear(StdStorage storage self) internal {
306
        delete self._target;
307
        delete self._sig;
308
        delete self._keys;
309
        delete self._depth;
310
        delete self._enable_packed_slots;
311
        delete self._calldata;
312
    }
313

                            
                        
314
    // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`
315
    // (slotValue & mask) >> offsetRight will be the value of the given packed variable
316
    function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {
317
        // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;
318
        // using assembly because (1 << 256) causes overflow
319
        assembly {
320
            mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))
321
        }
322
    }
323

                            
                        
324
    // Returns slot value with updated packed variable.
325
    function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
326
        internal
327
        pure
328
        returns (bytes32 newValue)
329
    {
330
        return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));
331
    }
332
}
333

                            
                        
334
library stdStorage {
335
    Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
336

                            
                        
337
    function sigs(string memory sigStr) internal pure returns (bytes4) {
338
        return stdStorageSafe.sigs(sigStr);
339
    }
340

                            
                        
341
    function find(StdStorage storage self) internal returns (uint256) {
342
        return find(self, true);
343
    }
344

                            
                        
345
    function find(StdStorage storage self, bool _clear) internal returns (uint256) {
346
        return stdStorageSafe.find(self, _clear).slot;
347
    }
348

                            
                        
349
    function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
350
        return stdStorageSafe.target(self, _target);
351
    }
352

                            
                        
353
    function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
354
        return stdStorageSafe.sig(self, _sig);
355
    }
356

                            
                        
357
    function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
358
        return stdStorageSafe.sig(self, _sig);
359
    }
360

                            
                        
361
    function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
362
        return stdStorageSafe.with_key(self, who);
363
    }
364

                            
                        
365
    function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
366
        return stdStorageSafe.with_key(self, amt);
367
    }
368

                            
                        
369
    function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
370
        return stdStorageSafe.with_key(self, key);
371
    }
372

                            
                        
373
    function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
374
        return stdStorageSafe.with_calldata(self, _calldata);
375
    }
376

                            
                        
377
    function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
378
        return stdStorageSafe.enable_packed_slots(self);
379
    }
380

                            
                        
381
    function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
382
        return stdStorageSafe.depth(self, _depth);
383
    }
384

                            
                        
385
    function clear(StdStorage storage self) internal {
386
        stdStorageSafe.clear(self);
387
    }
388

                            
                        
389
    function checked_write(StdStorage storage self, address who) internal {
390
        checked_write(self, bytes32(uint256(uint160(who))));
391
    }
392

                            
                        
393
    function checked_write(StdStorage storage self, uint256 amt) internal {
394
        checked_write(self, bytes32(amt));
395
    }
396

                            
                        
397
    function checked_write_int(StdStorage storage self, int256 val) internal {
398
        checked_write(self, bytes32(uint256(val)));
399
    }
400

                            
                        
401
    function checked_write(StdStorage storage self, bool write) internal {
402
        bytes32 t;
403
        /// @solidity memory-safe-assembly
404
        assembly {
405
            t := write
406
        }
407
        checked_write(self, t);
408
    }
409

                            
                        
410
    function checked_write(StdStorage storage self, bytes32 set) internal {
411
        address who = self._target;
412
        bytes4 fsig = self._sig;
413
        uint256 field_depth = self._depth;
414
        bytes memory params = stdStorageSafe.getCallParams(self);
415

                            
                        
416
        if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
417
            find(self, false);
418
        }
419
        FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
420
        if ((data.offsetLeft + data.offsetRight) > 0) {
421
            uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));
422
            require(
423
                uint256(set) < maxVal,
424
                string(
425
                    abi.encodePacked(
426
                        "stdStorage find(StdStorage): Packed slot. We can't fit value greater than ",
427
                        vm.toString(maxVal)
428
                    )
429
                )
430
            );
431
        }
432
        bytes32 curVal = vm.load(who, bytes32(data.slot));
433
        bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);
434

                            
                        
435
        vm.store(who, bytes32(data.slot), valToSet);
436

                            
                        
437
        (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);
438

                            
                        
439
        if (!success || callResult != set) {
440
            vm.store(who, bytes32(data.slot), curVal);
441
            revert("stdStorage find(StdStorage): Failed to write value.");
442
        }
443
        clear(self);
444
    }
445

                            
                        
446
    function read_bytes32(StdStorage storage self) internal returns (bytes32) {
447
        return stdStorageSafe.read_bytes32(self);
448
    }
449

                            
                        
450
    function read_bool(StdStorage storage self) internal returns (bool) {
451
        return stdStorageSafe.read_bool(self);
452
    }
453

                            
                        
454
    function read_address(StdStorage storage self) internal returns (address) {
455
        return stdStorageSafe.read_address(self);
456
    }
457

                            
                        
458
    function read_uint(StdStorage storage self) internal returns (uint256) {
459
        return stdStorageSafe.read_uint(self);
460
    }
461

                            
                        
462
    function read_int(StdStorage storage self) internal returns (int256) {
463
        return stdStorageSafe.read_int(self);
464
    }
465

                            
                        
466
    function parent(StdStorage storage self) internal returns (uint256, bytes32) {
467
        return stdStorageSafe.parent(self);
468
    }
469

                            
                        
470
    function root(StdStorage storage self) internal returns (uint256) {
471
        return stdStorageSafe.root(self);
472
    }
473
}
474

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.4.22 <0.9.0;
3

                            
                        
4
import {VmSafe} from "./Vm.sol";
5

                            
                        
6
library StdStyle {
7
    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
8

                            
                        
9
    string constant RED = "\u001b[91m";
10
    string constant GREEN = "\u001b[92m";
11
    string constant YELLOW = "\u001b[93m";
12
    string constant BLUE = "\u001b[94m";
13
    string constant MAGENTA = "\u001b[95m";
14
    string constant CYAN = "\u001b[96m";
15
    string constant BOLD = "\u001b[1m";
16
    string constant DIM = "\u001b[2m";
17
    string constant ITALIC = "\u001b[3m";
18
    string constant UNDERLINE = "\u001b[4m";
19
    string constant INVERSE = "\u001b[7m";
20
    string constant RESET = "\u001b[0m";
21

                            
                        
22
    function styleConcat(string memory style, string memory self) private pure returns (string memory) {
23
        return string(abi.encodePacked(style, self, RESET));
24
    }
25

                            
                        
26
    function red(string memory self) internal pure returns (string memory) {
27
        return styleConcat(RED, self);
28
    }
29

                            
                        
30
    function red(uint256 self) internal pure returns (string memory) {
31
        return red(vm.toString(self));
32
    }
33

                            
                        
34
    function red(int256 self) internal pure returns (string memory) {
35
        return red(vm.toString(self));
36
    }
37

                            
                        
38
    function red(address self) internal pure returns (string memory) {
39
        return red(vm.toString(self));
40
    }
41

                            
                        
42
    function red(bool self) internal pure returns (string memory) {
43
        return red(vm.toString(self));
44
    }
45

                            
                        
46
    function redBytes(bytes memory self) internal pure returns (string memory) {
47
        return red(vm.toString(self));
48
    }
49

                            
                        
50
    function redBytes32(bytes32 self) internal pure returns (string memory) {
51
        return red(vm.toString(self));
52
    }
53

                            
                        
54
    function green(string memory self) internal pure returns (string memory) {
55
        return styleConcat(GREEN, self);
56
    }
57

                            
                        
58
    function green(uint256 self) internal pure returns (string memory) {
59
        return green(vm.toString(self));
60
    }
61

                            
                        
62
    function green(int256 self) internal pure returns (string memory) {
63
        return green(vm.toString(self));
64
    }
65

                            
                        
66
    function green(address self) internal pure returns (string memory) {
67
        return green(vm.toString(self));
68
    }
69

                            
                        
70
    function green(bool self) internal pure returns (string memory) {
71
        return green(vm.toString(self));
72
    }
73

                            
                        
74
    function greenBytes(bytes memory self) internal pure returns (string memory) {
75
        return green(vm.toString(self));
76
    }
77

                            
                        
78
    function greenBytes32(bytes32 self) internal pure returns (string memory) {
79
        return green(vm.toString(self));
80
    }
81

                            
                        
82
    function yellow(string memory self) internal pure returns (string memory) {
83
        return styleConcat(YELLOW, self);
84
    }
85

                            
                        
86
    function yellow(uint256 self) internal pure returns (string memory) {
87
        return yellow(vm.toString(self));
88
    }
89

                            
                        
90
    function yellow(int256 self) internal pure returns (string memory) {
91
        return yellow(vm.toString(self));
92
    }
93

                            
                        
94
    function yellow(address self) internal pure returns (string memory) {
95
        return yellow(vm.toString(self));
96
    }
97

                            
                        
98
    function yellow(bool self) internal pure returns (string memory) {
99
        return yellow(vm.toString(self));
100
    }
101

                            
                        
102
    function yellowBytes(bytes memory self) internal pure returns (string memory) {
103
        return yellow(vm.toString(self));
104
    }
105

                            
                        
106
    function yellowBytes32(bytes32 self) internal pure returns (string memory) {
107
        return yellow(vm.toString(self));
108
    }
109

                            
                        
110
    function blue(string memory self) internal pure returns (string memory) {
111
        return styleConcat(BLUE, self);
112
    }
113

                            
                        
114
    function blue(uint256 self) internal pure returns (string memory) {
115
        return blue(vm.toString(self));
116
    }
117

                            
                        
118
    function blue(int256 self) internal pure returns (string memory) {
119
        return blue(vm.toString(self));
120
    }
121

                            
                        
122
    function blue(address self) internal pure returns (string memory) {
123
        return blue(vm.toString(self));
124
    }
125

                            
                        
126
    function blue(bool self) internal pure returns (string memory) {
127
        return blue(vm.toString(self));
128
    }
129

                            
                        
130
    function blueBytes(bytes memory self) internal pure returns (string memory) {
131
        return blue(vm.toString(self));
132
    }
133

                            
                        
134
    function blueBytes32(bytes32 self) internal pure returns (string memory) {
135
        return blue(vm.toString(self));
136
    }
137

                            
                        
138
    function magenta(string memory self) internal pure returns (string memory) {
139
        return styleConcat(MAGENTA, self);
140
    }
141

                            
                        
142
    function magenta(uint256 self) internal pure returns (string memory) {
143
        return magenta(vm.toString(self));
144
    }
145

                            
                        
146
    function magenta(int256 self) internal pure returns (string memory) {
147
        return magenta(vm.toString(self));
148
    }
149

                            
                        
150
    function magenta(address self) internal pure returns (string memory) {
151
        return magenta(vm.toString(self));
152
    }
153

                            
                        
154
    function magenta(bool self) internal pure returns (string memory) {
155
        return magenta(vm.toString(self));
156
    }
157

                            
                        
158
    function magentaBytes(bytes memory self) internal pure returns (string memory) {
159
        return magenta(vm.toString(self));
160
    }
161

                            
                        
162
    function magentaBytes32(bytes32 self) internal pure returns (string memory) {
163
        return magenta(vm.toString(self));
164
    }
165

                            
                        
166
    function cyan(string memory self) internal pure returns (string memory) {
167
        return styleConcat(CYAN, self);
168
    }
169

                            
                        
170
    function cyan(uint256 self) internal pure returns (string memory) {
171
        return cyan(vm.toString(self));
172
    }
173

                            
                        
174
    function cyan(int256 self) internal pure returns (string memory) {
175
        return cyan(vm.toString(self));
176
    }
177

                            
                        
178
    function cyan(address self) internal pure returns (string memory) {
179
        return cyan(vm.toString(self));
180
    }
181

                            
                        
182
    function cyan(bool self) internal pure returns (string memory) {
183
        return cyan(vm.toString(self));
184
    }
185

                            
                        
186
    function cyanBytes(bytes memory self) internal pure returns (string memory) {
187
        return cyan(vm.toString(self));
188
    }
189

                            
                        
190
    function cyanBytes32(bytes32 self) internal pure returns (string memory) {
191
        return cyan(vm.toString(self));
192
    }
193

                            
                        
194
    function bold(string memory self) internal pure returns (string memory) {
195
        return styleConcat(BOLD, self);
196
    }
197

                            
                        
198
    function bold(uint256 self) internal pure returns (string memory) {
199
        return bold(vm.toString(self));
200
    }
201

                            
                        
202
    function bold(int256 self) internal pure returns (string memory) {
203
        return bold(vm.toString(self));
204
    }
205

                            
                        
206
    function bold(address self) internal pure returns (string memory) {
207
        return bold(vm.toString(self));
208
    }
209

                            
                        
210
    function bold(bool self) internal pure returns (string memory) {
211
        return bold(vm.toString(self));
212
    }
213

                            
                        
214
    function boldBytes(bytes memory self) internal pure returns (string memory) {
215
        return bold(vm.toString(self));
216
    }
217

                            
                        
218
    function boldBytes32(bytes32 self) internal pure returns (string memory) {
219
        return bold(vm.toString(self));
220
    }
221

                            
                        
222
    function dim(string memory self) internal pure returns (string memory) {
223
        return styleConcat(DIM, self);
224
    }
225

                            
                        
226
    function dim(uint256 self) internal pure returns (string memory) {
227
        return dim(vm.toString(self));
228
    }
229

                            
                        
230
    function dim(int256 self) internal pure returns (string memory) {
231
        return dim(vm.toString(self));
232
    }
233

                            
                        
234
    function dim(address self) internal pure returns (string memory) {
235
        return dim(vm.toString(self));
236
    }
237

                            
                        
238
    function dim(bool self) internal pure returns (string memory) {
239
        return dim(vm.toString(self));
240
    }
241

                            
                        
242
    function dimBytes(bytes memory self) internal pure returns (string memory) {
243
        return dim(vm.toString(self));
244
    }
245

                            
                        
246
    function dimBytes32(bytes32 self) internal pure returns (string memory) {
247
        return dim(vm.toString(self));
248
    }
249

                            
                        
250
    function italic(string memory self) internal pure returns (string memory) {
251
        return styleConcat(ITALIC, self);
252
    }
253

                            
                        
254
    function italic(uint256 self) internal pure returns (string memory) {
255
        return italic(vm.toString(self));
256
    }
257

                            
                        
258
    function italic(int256 self) internal pure returns (string memory) {
259
        return italic(vm.toString(self));
260
    }
261

                            
                        
262
    function italic(address self) internal pure returns (string memory) {
263
        return italic(vm.toString(self));
264
    }
265

                            
                        
266
    function italic(bool self) internal pure returns (string memory) {
267
        return italic(vm.toString(self));
268
    }
269

                            
                        
270
    function italicBytes(bytes memory self) internal pure returns (string memory) {
271
        return italic(vm.toString(self));
272
    }
273

                            
                        
274
    function italicBytes32(bytes32 self) internal pure returns (string memory) {
275
        return italic(vm.toString(self));
276
    }
277

                            
                        
278
    function underline(string memory self) internal pure returns (string memory) {
279
        return styleConcat(UNDERLINE, self);
280
    }
281

                            
                        
282
    function underline(uint256 self) internal pure returns (string memory) {
283
        return underline(vm.toString(self));
284
    }
285

                            
                        
286
    function underline(int256 self) internal pure returns (string memory) {
287
        return underline(vm.toString(self));
288
    }
289

                            
                        
290
    function underline(address self) internal pure returns (string memory) {
291
        return underline(vm.toString(self));
292
    }
293

                            
                        
294
    function underline(bool self) internal pure returns (string memory) {
295
        return underline(vm.toString(self));
296
    }
297

                            
                        
298
    function underlineBytes(bytes memory self) internal pure returns (string memory) {
299
        return underline(vm.toString(self));
300
    }
301

                            
                        
302
    function underlineBytes32(bytes32 self) internal pure returns (string memory) {
303
        return underline(vm.toString(self));
304
    }
305

                            
                        
306
    function inverse(string memory self) internal pure returns (string memory) {
307
        return styleConcat(INVERSE, self);
308
    }
309

                            
                        
310
    function inverse(uint256 self) internal pure returns (string memory) {
311
        return inverse(vm.toString(self));
312
    }
313

                            
                        
314
    function inverse(int256 self) internal pure returns (string memory) {
315
        return inverse(vm.toString(self));
316
    }
317

                            
                        
318
    function inverse(address self) internal pure returns (string memory) {
319
        return inverse(vm.toString(self));
320
    }
321

                            
                        
322
    function inverse(bool self) internal pure returns (string memory) {
323
        return inverse(vm.toString(self));
324
    }
325

                            
                        
326
    function inverseBytes(bytes memory self) internal pure returns (string memory) {
327
        return inverse(vm.toString(self));
328
    }
329

                            
                        
330
    function inverseBytes32(bytes32 self) internal pure returns (string memory) {
331
        return inverse(vm.toString(self));
332
    }
333
}
334

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.0 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
import {VmSafe} from "./Vm.sol";
7

                            
                        
8
// Helpers for parsing and writing TOML files
9
// To parse:
10
// ```
11
// using stdToml for string;
12
// string memory toml = vm.readFile("<some_path>");
13
// toml.readUint("<json_path>");
14
// ```
15
// To write:
16
// ```
17
// using stdToml for string;
18
// string memory json = "json";
19
// json.serialize("a", uint256(123));
20
// string memory semiFinal = json.serialize("b", string("test"));
21
// string memory finalJson = json.serialize("c", semiFinal);
22
// finalJson.write("<some_path>");
23
// ```
24

                            
                        
25
library stdToml {
26
    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
27

                            
                        
28
    function keyExists(string memory toml, string memory key) internal view returns (bool) {
29
        return vm.keyExistsToml(toml, key);
30
    }
31

                            
                        
32
    function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) {
33
        return vm.parseToml(toml, key);
34
    }
35

                            
                        
36
    function readUint(string memory toml, string memory key) internal pure returns (uint256) {
37
        return vm.parseTomlUint(toml, key);
38
    }
39

                            
                        
40
    function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) {
41
        return vm.parseTomlUintArray(toml, key);
42
    }
43

                            
                        
44
    function readInt(string memory toml, string memory key) internal pure returns (int256) {
45
        return vm.parseTomlInt(toml, key);
46
    }
47

                            
                        
48
    function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) {
49
        return vm.parseTomlIntArray(toml, key);
50
    }
51

                            
                        
52
    function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) {
53
        return vm.parseTomlBytes32(toml, key);
54
    }
55

                            
                        
56
    function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) {
57
        return vm.parseTomlBytes32Array(toml, key);
58
    }
59

                            
                        
60
    function readString(string memory toml, string memory key) internal pure returns (string memory) {
61
        return vm.parseTomlString(toml, key);
62
    }
63

                            
                        
64
    function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) {
65
        return vm.parseTomlStringArray(toml, key);
66
    }
67

                            
                        
68
    function readAddress(string memory toml, string memory key) internal pure returns (address) {
69
        return vm.parseTomlAddress(toml, key);
70
    }
71

                            
                        
72
    function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) {
73
        return vm.parseTomlAddressArray(toml, key);
74
    }
75

                            
                        
76
    function readBool(string memory toml, string memory key) internal pure returns (bool) {
77
        return vm.parseTomlBool(toml, key);
78
    }
79

                            
                        
80
    function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) {
81
        return vm.parseTomlBoolArray(toml, key);
82
    }
83

                            
                        
84
    function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) {
85
        return vm.parseTomlBytes(toml, key);
86
    }
87

                            
                        
88
    function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) {
89
        return vm.parseTomlBytesArray(toml, key);
90
    }
91

                            
                        
92
    function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) {
93
        return keyExists(toml, key) ? readUint(toml, key) : defaultValue;
94
    }
95

                            
                        
96
    function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
97
        internal
98
        view
99
        returns (uint256[] memory)
100
    {
101
        return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue;
102
    }
103

                            
                        
104
    function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) {
105
        return keyExists(toml, key) ? readInt(toml, key) : defaultValue;
106
    }
107

                            
                        
108
    function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
109
        internal
110
        view
111
        returns (int256[] memory)
112
    {
113
        return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue;
114
    }
115

                            
                        
116
    function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue)
117
        internal
118
        view
119
        returns (bytes32)
120
    {
121
        return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue;
122
    }
123

                            
                        
124
    function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
125
        internal
126
        view
127
        returns (bytes32[] memory)
128
    {
129
        return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue;
130
    }
131

                            
                        
132
    function readStringOr(string memory toml, string memory key, string memory defaultValue)
133
        internal
134
        view
135
        returns (string memory)
136
    {
137
        return keyExists(toml, key) ? readString(toml, key) : defaultValue;
138
    }
139

                            
                        
140
    function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
141
        internal
142
        view
143
        returns (string[] memory)
144
    {
145
        return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue;
146
    }
147

                            
                        
148
    function readAddressOr(string memory toml, string memory key, address defaultValue)
149
        internal
150
        view
151
        returns (address)
152
    {
153
        return keyExists(toml, key) ? readAddress(toml, key) : defaultValue;
154
    }
155

                            
                        
156
    function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
157
        internal
158
        view
159
        returns (address[] memory)
160
    {
161
        return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue;
162
    }
163

                            
                        
164
    function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) {
165
        return keyExists(toml, key) ? readBool(toml, key) : defaultValue;
166
    }
167

                            
                        
168
    function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
169
        internal
170
        view
171
        returns (bool[] memory)
172
    {
173
        return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue;
174
    }
175

                            
                        
176
    function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
177
        internal
178
        view
179
        returns (bytes memory)
180
    {
181
        return keyExists(toml, key) ? readBytes(toml, key) : defaultValue;
182
    }
183

                            
                        
184
    function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
185
        internal
186
        view
187
        returns (bytes[] memory)
188
    {
189
        return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue;
190
    }
191

                            
                        
192
    function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
193
        return vm.serializeJson(jsonKey, rootObject);
194
    }
195

                            
                        
196
    function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
197
        return vm.serializeBool(jsonKey, key, value);
198
    }
199

                            
                        
200
    function serialize(string memory jsonKey, string memory key, bool[] memory value)
201
        internal
202
        returns (string memory)
203
    {
204
        return vm.serializeBool(jsonKey, key, value);
205
    }
206

                            
                        
207
    function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
208
        return vm.serializeUint(jsonKey, key, value);
209
    }
210

                            
                        
211
    function serialize(string memory jsonKey, string memory key, uint256[] memory value)
212
        internal
213
        returns (string memory)
214
    {
215
        return vm.serializeUint(jsonKey, key, value);
216
    }
217

                            
                        
218
    function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
219
        return vm.serializeInt(jsonKey, key, value);
220
    }
221

                            
                        
222
    function serialize(string memory jsonKey, string memory key, int256[] memory value)
223
        internal
224
        returns (string memory)
225
    {
226
        return vm.serializeInt(jsonKey, key, value);
227
    }
228

                            
                        
229
    function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
230
        return vm.serializeAddress(jsonKey, key, value);
231
    }
232

                            
                        
233
    function serialize(string memory jsonKey, string memory key, address[] memory value)
234
        internal
235
        returns (string memory)
236
    {
237
        return vm.serializeAddress(jsonKey, key, value);
238
    }
239

                            
                        
240
    function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
241
        return vm.serializeBytes32(jsonKey, key, value);
242
    }
243

                            
                        
244
    function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
245
        internal
246
        returns (string memory)
247
    {
248
        return vm.serializeBytes32(jsonKey, key, value);
249
    }
250

                            
                        
251
    function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
252
        return vm.serializeBytes(jsonKey, key, value);
253
    }
254

                            
                        
255
    function serialize(string memory jsonKey, string memory key, bytes[] memory value)
256
        internal
257
        returns (string memory)
258
    {
259
        return vm.serializeBytes(jsonKey, key, value);
260
    }
261

                            
                        
262
    function serialize(string memory jsonKey, string memory key, string memory value)
263
        internal
264
        returns (string memory)
265
    {
266
        return vm.serializeString(jsonKey, key, value);
267
    }
268

                            
                        
269
    function serialize(string memory jsonKey, string memory key, string[] memory value)
270
        internal
271
        returns (string memory)
272
    {
273
        return vm.serializeString(jsonKey, key, value);
274
    }
275

                            
                        
276
    function write(string memory jsonKey, string memory path) internal {
277
        vm.writeToml(jsonKey, path);
278
    }
279

                            
                        
280
    function write(string memory jsonKey, string memory path, string memory valueKey) internal {
281
        vm.writeToml(jsonKey, path, valueKey);
282
    }
283
}
284

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
import {IMulticall3} from "./interfaces/IMulticall3.sol";
7
import {MockERC20} from "./mocks/MockERC20.sol";
8
import {MockERC721} from "./mocks/MockERC721.sol";
9
import {VmSafe} from "./Vm.sol";
10

                            
                        
11
abstract contract StdUtils {
12
    /*//////////////////////////////////////////////////////////////////////////
13
                                     CONSTANTS
14
    //////////////////////////////////////////////////////////////////////////*/
15

                            
                        
16
    IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
17
    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
18
    address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
19
    uint256 private constant INT256_MIN_ABS =
20
        57896044618658097711785492504343953926634992332820282019728792003956564819968;
21
    uint256 private constant SECP256K1_ORDER =
22
        115792089237316195423570985008687907852837564279074904382605163141518161494337;
23
    uint256 private constant UINT256_MAX =
24
        115792089237316195423570985008687907853269984665640564039457584007913129639935;
25

                            
                        
26
    // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
27
    address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
28

                            
                        
29
    /*//////////////////////////////////////////////////////////////////////////
30
                                 INTERNAL FUNCTIONS
31
    //////////////////////////////////////////////////////////////////////////*/
32

                            
                        
33
    function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
34
        require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
35
        // If x is between min and max, return x directly. This is to ensure that dictionary values
36
        // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
37
        if (x >= min && x <= max) return x;
38

                            
                        
39
        uint256 size = max - min + 1;
40

                            
                        
41
        // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.
42
        // This helps ensure coverage of the min/max values.
43
        if (x <= 3 && size > x) return min + x;
44
        if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);
45

                            
                        
46
        // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
47
        if (x > max) {
48
            uint256 diff = x - max;
49
            uint256 rem = diff % size;
50
            if (rem == 0) return max;
51
            result = min + rem - 1;
52
        } else if (x < min) {
53
            uint256 diff = min - x;
54
            uint256 rem = diff % size;
55
            if (rem == 0) return min;
56
            result = max - rem + 1;
57
        }
58
    }
59

                            
                        
60
    function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
61
        result = _bound(x, min, max);
62
        console2_log_StdUtils("Bound result", result);
63
    }
64

                            
                        
65
    function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
66
        require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
67

                            
                        
68
        // Shifting all int256 values to uint256 to use _bound function. The range of two types are:
69
        // int256 : -(2**255) ~ (2**255 - 1)
70
        // uint256:     0     ~ (2**256 - 1)
71
        // So, add 2**255, INT256_MIN_ABS to the integer values.
72
        //
73
        // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
74
        // So, use `~uint256(x) + 1` instead.
75
        uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);
76
        uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);
77
        uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);
78

                            
                        
79
        uint256 y = _bound(_x, _min, _max);
80

                            
                        
81
        // To move it back to int256 value, subtract INT256_MIN_ABS at here.
82
        result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);
83
    }
84

                            
                        
85
    function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
86
        result = _bound(x, min, max);
87
        console2_log_StdUtils("Bound result", vm.toString(result));
88
    }
89

                            
                        
90
    function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
91
        result = _bound(privateKey, 1, SECP256K1_ORDER - 1);
92
    }
93

                            
                        
94
    function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
95
        require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
96
        return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
97
    }
98

                            
                        
99
    /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce
100
    /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)
101
    function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
102
        console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
103
        return vm.computeCreateAddress(deployer, nonce);
104
    }
105

                            
                        
106
    function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
107
        internal
108
        pure
109
        virtual
110
        returns (address)
111
    {
112
        console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
113
        return vm.computeCreate2Address(salt, initcodeHash, deployer);
114
    }
115

                            
                        
116
    /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer
117
    function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
118
        console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
119
        return vm.computeCreate2Address(salt, initCodeHash);
120
    }
121

                            
                        
122
    /// @dev returns an initialized mock ERC20 contract
123
    function deployMockERC20(string memory name, string memory symbol, uint8 decimals)
124
        internal
125
        returns (MockERC20 mock)
126
    {
127
        mock = new MockERC20();
128
        mock.initialize(name, symbol, decimals);
129
    }
130

                            
                        
131
    /// @dev returns an initialized mock ERC721 contract
132
    function deployMockERC721(string memory name, string memory symbol) internal returns (MockERC721 mock) {
133
        mock = new MockERC721();
134
        mock.initialize(name, symbol);
135
    }
136

                            
                        
137
    /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments
138
    /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
139
    function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
140
        return hashInitCode(creationCode, "");
141
    }
142

                            
                        
143
    /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2
144
    /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
145
    /// @param args the ABI-encoded arguments to the constructor of C
146
    function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
147
        return keccak256(abi.encodePacked(creationCode, args));
148
    }
149

                            
                        
150
    // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.
151
    function getTokenBalances(address token, address[] memory addresses)
152
        internal
153
        virtual
154
        returns (uint256[] memory balances)
155
    {
156
        uint256 tokenCodeSize;
157
        assembly {
158
            tokenCodeSize := extcodesize(token)
159
        }
160
        require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
161

                            
                        
162
        // ABI encode the aggregate call to Multicall3.
163
        uint256 length = addresses.length;
164
        IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
165
        for (uint256 i = 0; i < length; ++i) {
166
            // 0x70a08231 = bytes4("balanceOf(address)"))
167
            calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
168
        }
169

                            
                        
170
        // Make the aggregate call.
171
        (, bytes[] memory returnData) = multicall.aggregate(calls);
172

                            
                        
173
        // ABI decode the return data and return the balances.
174
        balances = new uint256[](length);
175
        for (uint256 i = 0; i < length; ++i) {
176
            balances[i] = abi.decode(returnData[i], (uint256));
177
        }
178
    }
179

                            
                        
180
    /*//////////////////////////////////////////////////////////////////////////
181
                                 PRIVATE FUNCTIONS
182
    //////////////////////////////////////////////////////////////////////////*/
183

                            
                        
184
    function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
185
        return address(uint160(uint256(bytesValue)));
186
    }
187

                            
                        
188
    // This section is used to prevent the compilation of console, which shortens the compilation time when console is
189
    // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
190
    // any breaking changes to function signatures.
191
    function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
192
        internal
193
        pure
194
        returns (function(bytes memory) internal pure fnOut)
195
    {
196
        assembly {
197
            fnOut := fnIn
198
        }
199
    }
200

                            
                        
201
    function _sendLogPayload(bytes memory payload) internal pure {
202
        _castLogPayloadViewToPure(_sendLogPayloadView)(payload);
203
    }
204

                            
                        
205
    function _sendLogPayloadView(bytes memory payload) private view {
206
        uint256 payloadLength = payload.length;
207
        address consoleAddress = CONSOLE2_ADDRESS;
208
        /// @solidity memory-safe-assembly
209
        assembly {
210
            let payloadStart := add(payload, 32)
211
            let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
212
        }
213
    }
214

                            
                        
215
    function console2_log_StdUtils(string memory p0) private pure {
216
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
217
    }
218

                            
                        
219
    function console2_log_StdUtils(string memory p0, uint256 p1) private pure {
220
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
221
    }
222

                            
                        
223
    function console2_log_StdUtils(string memory p0, string memory p1) private pure {
224
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
225
    }
226
}
227

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
// 💬 ABOUT
7
// Forge Std's default Test.
8

                            
                        
9
// 🧩 MODULES
10
import {console} from "./console.sol";
11
import {console2} from "./console2.sol";
12
import {safeconsole} from "./safeconsole.sol";
13
import {StdAssertions} from "./StdAssertions.sol";
14
import {StdChains} from "./StdChains.sol";
15
import {StdCheats} from "./StdCheats.sol";
16
import {stdError} from "./StdError.sol";
17
import {StdInvariant} from "./StdInvariant.sol";
18
import {stdJson} from "./StdJson.sol";
19
import {stdMath} from "./StdMath.sol";
20
import {StdStorage, stdStorage} from "./StdStorage.sol";
21
import {StdStyle} from "./StdStyle.sol";
22
import {stdToml} from "./StdToml.sol";
23
import {StdUtils} from "./StdUtils.sol";
24
import {Vm} from "./Vm.sol";
25

                            
                        
26
// 📦 BOILERPLATE
27
import {TestBase} from "./Base.sol";
28

                            
                        
29
// ⭐️ TEST
30
abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
31
    // Note: IS_TEST() must return true.
32
    bool public IS_TEST = true;
33
}
34

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// Automatically @generated by scripts/vm.py. Do not modify manually.
2

                            
                        
3
// SPDX-License-Identifier: MIT OR Apache-2.0
4
pragma solidity >=0.6.2 <0.9.0;
5
pragma experimental ABIEncoderV2;
6

                            
                        
7
/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
8
/// result in Script simulations differing from on-chain execution. It is recommended to only use
9
/// these cheats in scripts.
10
interface VmSafe {
11
    /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.
12
    enum CallerMode {
13
        // No caller modification is currently active.
14
        None,
15
        // A one time broadcast triggered by a `vm.broadcast()` call is currently active.
16
        Broadcast,
17
        // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.
18
        RecurrentBroadcast,
19
        // A one time prank triggered by a `vm.prank()` call is currently active.
20
        Prank,
21
        // A recurrent prank triggered by a `vm.startPrank()` call is currently active.
22
        RecurrentPrank
23
    }
24

                            
                        
25
    /// The kind of account access that occurred.
26
    enum AccountAccessKind {
27
        // The account was called.
28
        Call,
29
        // The account was called via delegatecall.
30
        DelegateCall,
31
        // The account was called via callcode.
32
        CallCode,
33
        // The account was called via staticcall.
34
        StaticCall,
35
        // The account was created.
36
        Create,
37
        // The account was selfdestructed.
38
        SelfDestruct,
39
        // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).
40
        Resume,
41
        // The account's balance was read.
42
        Balance,
43
        // The account's codesize was read.
44
        Extcodesize,
45
        // The account's codehash was read.
46
        Extcodehash,
47
        // The account's code was copied.
48
        Extcodecopy
49
    }
50

                            
                        
51
    /// Forge execution contexts.
52
    enum ForgeContext {
53
        // Test group execution context (test, coverage or snapshot).
54
        TestGroup,
55
        // `forge test` execution context.
56
        Test,
57
        // `forge coverage` execution context.
58
        Coverage,
59
        // `forge snapshot` execution context.
60
        Snapshot,
61
        // Script group execution context (dry run, broadcast or resume).
62
        ScriptGroup,
63
        // `forge script` execution context.
64
        ScriptDryRun,
65
        // `forge script --broadcast` execution context.
66
        ScriptBroadcast,
67
        // `forge script --resume` execution context.
68
        ScriptResume,
69
        // Unknown `forge` execution context.
70
        Unknown
71
    }
72

                            
                        
73
    /// An Ethereum log. Returned by `getRecordedLogs`.
74
    struct Log {
75
        // The topics of the log, including the signature, if any.
76
        bytes32[] topics;
77
        // The raw data of the log.
78
        bytes data;
79
        // The address of the log's emitter.
80
        address emitter;
81
    }
82

                            
                        
83
    /// An RPC URL and its alias. Returned by `rpcUrlStructs`.
84
    struct Rpc {
85
        // The alias of the RPC URL.
86
        string key;
87
        // The RPC URL.
88
        string url;
89
    }
90

                            
                        
91
    /// An RPC log object. Returned by `eth_getLogs`.
92
    struct EthGetLogs {
93
        // The address of the log's emitter.
94
        address emitter;
95
        // The topics of the log, including the signature, if any.
96
        bytes32[] topics;
97
        // The raw data of the log.
98
        bytes data;
99
        // The block hash.
100
        bytes32 blockHash;
101
        // The block number.
102
        uint64 blockNumber;
103
        // The transaction hash.
104
        bytes32 transactionHash;
105
        // The transaction index in the block.
106
        uint64 transactionIndex;
107
        // The log index.
108
        uint256 logIndex;
109
        // Whether the log was removed.
110
        bool removed;
111
    }
112

                            
                        
113
    /// A single entry in a directory listing. Returned by `readDir`.
114
    struct DirEntry {
115
        // The error message, if any.
116
        string errorMessage;
117
        // The path of the entry.
118
        string path;
119
        // The depth of the entry.
120
        uint64 depth;
121
        // Whether the entry is a directory.
122
        bool isDir;
123
        // Whether the entry is a symlink.
124
        bool isSymlink;
125
    }
126

                            
                        
127
    /// Metadata information about a file.
128
    /// This structure is returned from the `fsMetadata` function and represents known
129
    /// metadata about a file such as its permissions, size, modification
130
    /// times, etc.
131
    struct FsMetadata {
132
        // True if this metadata is for a directory.
133
        bool isDir;
134
        // True if this metadata is for a symlink.
135
        bool isSymlink;
136
        // The size of the file, in bytes, this metadata is for.
137
        uint256 length;
138
        // True if this metadata is for a readonly (unwritable) file.
139
        bool readOnly;
140
        // The last modification time listed in this metadata.
141
        uint256 modified;
142
        // The last access time of this metadata.
143
        uint256 accessed;
144
        // The creation time listed in this metadata.
145
        uint256 created;
146
    }
147

                            
                        
148
    /// A wallet with a public and private key.
149
    struct Wallet {
150
        // The wallet's address.
151
        address addr;
152
        // The wallet's public key `X`.
153
        uint256 publicKeyX;
154
        // The wallet's public key `Y`.
155
        uint256 publicKeyY;
156
        // The wallet's private key.
157
        uint256 privateKey;
158
    }
159

                            
                        
160
    /// The result of a `tryFfi` call.
161
    struct FfiResult {
162
        // The exit code of the call.
163
        int32 exitCode;
164
        // The optionally hex-decoded `stdout` data.
165
        bytes stdout;
166
        // The `stderr` data.
167
        bytes stderr;
168
    }
169

                            
                        
170
    /// Information on the chain and fork.
171
    struct ChainInfo {
172
        // The fork identifier. Set to zero if no fork is active.
173
        uint256 forkId;
174
        // The chain ID of the current fork.
175
        uint256 chainId;
176
    }
177

                            
                        
178
    /// The result of a `stopAndReturnStateDiff` call.
179
    struct AccountAccess {
180
        // The chain and fork the access occurred.
181
        ChainInfo chainInfo;
182
        // The kind of account access that determines what the account is.
183
        // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.
184
        // If kind is Create, then the account is the newly created account.
185
        // If kind is SelfDestruct, then the account is the selfdestruct recipient.
186
        // If kind is a Resume, then account represents a account context that has resumed.
187
        AccountAccessKind kind;
188
        // The account that was accessed.
189
        // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.
190
        address account;
191
        // What accessed the account.
192
        address accessor;
193
        // If the account was initialized or empty prior to the access.
194
        // An account is considered initialized if it has code, a
195
        // non-zero nonce, or a non-zero balance.
196
        bool initialized;
197
        // The previous balance of the accessed account.
198
        uint256 oldBalance;
199
        // The potential new balance of the accessed account.
200
        // That is, all balance changes are recorded here, even if reverts occurred.
201
        uint256 newBalance;
202
        // Code of the account deployed by CREATE.
203
        bytes deployedCode;
204
        // Value passed along with the account access
205
        uint256 value;
206
        // Input data provided to the CREATE or CALL
207
        bytes data;
208
        // If this access reverted in either the current or parent context.
209
        bool reverted;
210
        // An ordered list of storage accesses made during an account access operation.
211
        StorageAccess[] storageAccesses;
212
        // Call depth traversed during the recording of state differences
213
        uint64 depth;
214
    }
215

                            
                        
216
    /// The storage accessed during an `AccountAccess`.
217
    struct StorageAccess {
218
        // The account whose storage was accessed.
219
        address account;
220
        // The slot that was accessed.
221
        bytes32 slot;
222
        // If the access was a write.
223
        bool isWrite;
224
        // The previous value of the slot.
225
        bytes32 previousValue;
226
        // The new value of the slot.
227
        bytes32 newValue;
228
        // If the access was reverted.
229
        bool reverted;
230
    }
231

                            
                        
232
    /// Gas used. Returned by `lastCallGas`.
233
    struct Gas {
234
        // The gas limit of the call.
235
        uint64 gasLimit;
236
        // The total gas used.
237
        uint64 gasTotalUsed;
238
        // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939>
239
        uint64 gasMemoryUsed;
240
        // The amount of gas refunded.
241
        int64 gasRefunded;
242
        // The amount of gas remaining.
243
        uint64 gasRemaining;
244
    }
245

                            
                        
246
    /// The result of the `stopDebugTraceRecording` call
247
    struct DebugStep {
248
        // The stack before executing the step of the run.
249
        // stack\[0\] represents the top of the stack.
250
        // and only stack data relevant to the opcode execution is contained.
251
        uint256[] stack;
252
        // The memory input data before executing the step of the run.
253
        // only input data relevant to the opcode execution is contained.
254
        // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here.
255
        // the offset value can be get by the stack data.
256
        bytes memoryInput;
257
        // The opcode that was accessed.
258
        uint8 opcode;
259
        // The call depth of the step.
260
        uint64 depth;
261
        // Whether the call end up with out of gas error.
262
        bool isOutOfGas;
263
        // The contract address where the opcode is running
264
        address contractAddr;
265
    }
266

                            
                        
267
    // ======== Crypto ========
268

                            
                        
269
    /// Derives a private key from the name, labels the account with that name, and returns the wallet.
270
    function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);
271

                            
                        
272
    /// Generates a wallet from the private key and returns the wallet.
273
    function createWallet(uint256 privateKey) external returns (Wallet memory wallet);
274

                            
                        
275
    /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.
276
    function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);
277

                            
                        
278
    /// Derive a private key from a provided mnenomic string (or mnenomic file path)
279
    /// at the derivation path `m/44'/60'/0'/0/{index}`.
280
    function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);
281

                            
                        
282
    /// Derive a private key from a provided mnenomic string (or mnenomic file path)
283
    /// at `{derivationPath}{index}`.
284
    function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
285
        external
286
        pure
287
        returns (uint256 privateKey);
288

                            
                        
289
    /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
290
    /// at the derivation path `m/44'/60'/0'/0/{index}`.
291
    function deriveKey(string calldata mnemonic, uint32 index, string calldata language)
292
        external
293
        pure
294
        returns (uint256 privateKey);
295

                            
                        
296
    /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language
297
    /// at `{derivationPath}{index}`.
298
    function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)
299
        external
300
        pure
301
        returns (uint256 privateKey);
302

                            
                        
303
    /// Derives secp256r1 public key from the provided `privateKey`.
304
    function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);
305

                            
                        
306
    /// Adds a private key to the local forge wallet and returns the address.
307
    function rememberKey(uint256 privateKey) external returns (address keyAddr);
308

                            
                        
309
    /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.
310
    ///
311
    /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
312
    function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)
313
        external
314
        returns (address[] memory keyAddrs);
315

                            
                        
316
    /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.
317
    ///
318
    /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
319
    function rememberKeys(
320
        string calldata mnemonic,
321
        string calldata derivationPath,
322
        string calldata language,
323
        uint32 count
324
    ) external returns (address[] memory keyAddrs);
325

                            
                        
326
    /// Signs data with a `Wallet`.
327
    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
328
    /// signature's `s` value, and the recovery id `v` in a single bytes32.
329
    /// This format reduces the signature size from 65 to 64 bytes.
330
    function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);
331

                            
                        
332
    /// Signs `digest` with `privateKey` using the secp256k1 curve.
333
    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
334
    /// signature's `s` value, and the recovery id `v` in a single bytes32.
335
    /// This format reduces the signature size from 65 to 64 bytes.
336
    function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
337

                            
                        
338
    /// Signs `digest` with signer provided to script using the secp256k1 curve.
339
    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
340
    /// signature's `s` value, and the recovery id `v` in a single bytes32.
341
    /// This format reduces the signature size from 65 to 64 bytes.
342
    /// If `--sender` is provided, the signer with provided address is used, otherwise,
343
    /// if exactly one signer is provided to the script, that signer is used.
344
    /// Raises error if signer passed through `--sender` does not match any unlocked signers or
345
    /// if `--sender` is not provided and not exactly one signer is passed to the script.
346
    function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
347

                            
                        
348
    /// Signs `digest` with signer provided to script using the secp256k1 curve.
349
    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
350
    /// signature's `s` value, and the recovery id `v` in a single bytes32.
351
    /// This format reduces the signature size from 65 to 64 bytes.
352
    /// Raises error if none of the signers passed into the script have provided address.
353
    function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
354

                            
                        
355
    /// Signs `digest` with `privateKey` using the secp256r1 curve.
356
    function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);
357

                            
                        
358
    /// Signs data with a `Wallet`.
359
    function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
360

                            
                        
361
    /// Signs `digest` with `privateKey` using the secp256k1 curve.
362
    function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
363

                            
                        
364
    /// Signs `digest` with signer provided to script using the secp256k1 curve.
365
    /// If `--sender` is provided, the signer with provided address is used, otherwise,
366
    /// if exactly one signer is provided to the script, that signer is used.
367
    /// Raises error if signer passed through `--sender` does not match any unlocked signers or
368
    /// if `--sender` is not provided and not exactly one signer is passed to the script.
369
    function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
370

                            
                        
371
    /// Signs `digest` with signer provided to script using the secp256k1 curve.
372
    /// Raises error if none of the signers passed into the script have provided address.
373
    function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
374

                            
                        
375
    // ======== Environment ========
376

                            
                        
377
    /// Gets the environment variable `name` and parses it as `address`.
378
    /// Reverts if the variable was not found or could not be parsed.
379
    function envAddress(string calldata name) external view returns (address value);
380

                            
                        
381
    /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
382
    /// Reverts if the variable was not found or could not be parsed.
383
    function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);
384

                            
                        
385
    /// Gets the environment variable `name` and parses it as `bool`.
386
    /// Reverts if the variable was not found or could not be parsed.
387
    function envBool(string calldata name) external view returns (bool value);
388

                            
                        
389
    /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
390
    /// Reverts if the variable was not found or could not be parsed.
391
    function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);
392

                            
                        
393
    /// Gets the environment variable `name` and parses it as `bytes32`.
394
    /// Reverts if the variable was not found or could not be parsed.
395
    function envBytes32(string calldata name) external view returns (bytes32 value);
396

                            
                        
397
    /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
398
    /// Reverts if the variable was not found or could not be parsed.
399
    function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);
400

                            
                        
401
    /// Gets the environment variable `name` and parses it as `bytes`.
402
    /// Reverts if the variable was not found or could not be parsed.
403
    function envBytes(string calldata name) external view returns (bytes memory value);
404

                            
                        
405
    /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
406
    /// Reverts if the variable was not found or could not be parsed.
407
    function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);
408

                            
                        
409
    /// Gets the environment variable `name` and returns true if it exists, else returns false.
410
    function envExists(string calldata name) external view returns (bool result);
411

                            
                        
412
    /// Gets the environment variable `name` and parses it as `int256`.
413
    /// Reverts if the variable was not found or could not be parsed.
414
    function envInt(string calldata name) external view returns (int256 value);
415

                            
                        
416
    /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
417
    /// Reverts if the variable was not found or could not be parsed.
418
    function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);
419

                            
                        
420
    /// Gets the environment variable `name` and parses it as `bool`.
421
    /// Reverts if the variable could not be parsed.
422
    /// Returns `defaultValue` if the variable was not found.
423
    function envOr(string calldata name, bool defaultValue) external view returns (bool value);
424

                            
                        
425
    /// Gets the environment variable `name` and parses it as `uint256`.
426
    /// Reverts if the variable could not be parsed.
427
    /// Returns `defaultValue` if the variable was not found.
428
    function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);
429

                            
                        
430
    /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
431
    /// Reverts if the variable could not be parsed.
432
    /// Returns `defaultValue` if the variable was not found.
433
    function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
434
        external
435
        view
436
        returns (address[] memory value);
437

                            
                        
438
    /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
439
    /// Reverts if the variable could not be parsed.
440
    /// Returns `defaultValue` if the variable was not found.
441
    function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
442
        external
443
        view
444
        returns (bytes32[] memory value);
445

                            
                        
446
    /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
447
    /// Reverts if the variable could not be parsed.
448
    /// Returns `defaultValue` if the variable was not found.
449
    function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
450
        external
451
        view
452
        returns (string[] memory value);
453

                            
                        
454
    /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
455
    /// Reverts if the variable could not be parsed.
456
    /// Returns `defaultValue` if the variable was not found.
457
    function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
458
        external
459
        view
460
        returns (bytes[] memory value);
461

                            
                        
462
    /// Gets the environment variable `name` and parses it as `int256`.
463
    /// Reverts if the variable could not be parsed.
464
    /// Returns `defaultValue` if the variable was not found.
465
    function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);
466

                            
                        
467
    /// Gets the environment variable `name` and parses it as `address`.
468
    /// Reverts if the variable could not be parsed.
469
    /// Returns `defaultValue` if the variable was not found.
470
    function envOr(string calldata name, address defaultValue) external view returns (address value);
471

                            
                        
472
    /// Gets the environment variable `name` and parses it as `bytes32`.
473
    /// Reverts if the variable could not be parsed.
474
    /// Returns `defaultValue` if the variable was not found.
475
    function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);
476

                            
                        
477
    /// Gets the environment variable `name` and parses it as `string`.
478
    /// Reverts if the variable could not be parsed.
479
    /// Returns `defaultValue` if the variable was not found.
480
    function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);
481

                            
                        
482
    /// Gets the environment variable `name` and parses it as `bytes`.
483
    /// Reverts if the variable could not be parsed.
484
    /// Returns `defaultValue` if the variable was not found.
485
    function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);
486

                            
                        
487
    /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
488
    /// Reverts if the variable could not be parsed.
489
    /// Returns `defaultValue` if the variable was not found.
490
    function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
491
        external
492
        view
493
        returns (bool[] memory value);
494

                            
                        
495
    /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
496
    /// Reverts if the variable could not be parsed.
497
    /// Returns `defaultValue` if the variable was not found.
498
    function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
499
        external
500
        view
501
        returns (uint256[] memory value);
502

                            
                        
503
    /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
504
    /// Reverts if the variable could not be parsed.
505
    /// Returns `defaultValue` if the variable was not found.
506
    function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
507
        external
508
        view
509
        returns (int256[] memory value);
510

                            
                        
511
    /// Gets the environment variable `name` and parses it as `string`.
512
    /// Reverts if the variable was not found or could not be parsed.
513
    function envString(string calldata name) external view returns (string memory value);
514

                            
                        
515
    /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
516
    /// Reverts if the variable was not found or could not be parsed.
517
    function envString(string calldata name, string calldata delim) external view returns (string[] memory value);
518

                            
                        
519
    /// Gets the environment variable `name` and parses it as `uint256`.
520
    /// Reverts if the variable was not found or could not be parsed.
521
    function envUint(string calldata name) external view returns (uint256 value);
522

                            
                        
523
    /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
524
    /// Reverts if the variable was not found or could not be parsed.
525
    function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);
526

                            
                        
527
    /// Returns true if `forge` command was executed in given context.
528
    function isContext(ForgeContext context) external view returns (bool result);
529

                            
                        
530
    /// Sets environment variables.
531
    function setEnv(string calldata name, string calldata value) external;
532

                            
                        
533
    // ======== EVM ========
534

                            
                        
535
    /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.
536
    function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);
537

                            
                        
538
    /// Gets the address for a given private key.
539
    function addr(uint256 privateKey) external pure returns (address keyAddr);
540

                            
                        
541
    /// Gets all the logs according to specified filter.
542
    function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
543
        external
544
        returns (EthGetLogs[] memory logs);
545

                            
                        
546
    /// Gets the current `block.blobbasefee`.
547
    /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,
548
    /// and as a result will get optimized out by the compiler.
549
    /// See https://github.com/foundry-rs/foundry/issues/6180
550
    function getBlobBaseFee() external view returns (uint256 blobBaseFee);
551

                            
                        
552
    /// Gets the current `block.number`.
553
    /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,
554
    /// and as a result will get optimized out by the compiler.
555
    /// See https://github.com/foundry-rs/foundry/issues/6180
556
    function getBlockNumber() external view returns (uint256 height);
557

                            
                        
558
    /// Gets the current `block.timestamp`.
559
    /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,
560
    /// and as a result will get optimized out by the compiler.
561
    /// See https://github.com/foundry-rs/foundry/issues/6180
562
    function getBlockTimestamp() external view returns (uint256 timestamp);
563

                            
                        
564
    /// Gets the map key and parent of a mapping at a given slot, for a given address.
565
    function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
566
        external
567
        returns (bool found, bytes32 key, bytes32 parent);
568

                            
                        
569
    /// Gets the number of elements in the mapping at the given slot, for a given address.
570
    function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);
571

                            
                        
572
    /// Gets the elements at index idx of the mapping at the given slot, for a given address. The
573
    /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).
574
    function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);
575

                            
                        
576
    /// Gets the nonce of an account.
577
    function getNonce(address account) external view returns (uint64 nonce);
578

                            
                        
579
    /// Get the nonce of a `Wallet`.
580
    function getNonce(Wallet calldata wallet) external returns (uint64 nonce);
581

                            
                        
582
    /// Gets all the recorded logs.
583
    function getRecordedLogs() external returns (Log[] memory logs);
584

                            
                        
585
    /// Gets the gas used in the last call from the callee perspective.
586
    function lastCallGas() external view returns (Gas memory gas);
587

                            
                        
588
    /// Loads a storage slot from an address.
589
    function load(address target, bytes32 slot) external view returns (bytes32 data);
590

                            
                        
591
    /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.
592
    function pauseGasMetering() external;
593

                            
                        
594
    /// Records all storage reads and writes.
595
    function record() external;
596

                            
                        
597
    /// Record all the transaction logs.
598
    function recordLogs() external;
599

                            
                        
600
    /// Reset gas metering (i.e. gas usage is set to gas limit).
601
    function resetGasMetering() external;
602

                            
                        
603
    /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.
604
    function resumeGasMetering() external;
605

                            
                        
606
    /// Performs an Ethereum JSON-RPC request to the current fork URL.
607
    function rpc(string calldata method, string calldata params) external returns (bytes memory data);
608

                            
                        
609
    /// Performs an Ethereum JSON-RPC request to the given endpoint.
610
    function rpc(string calldata urlOrAlias, string calldata method, string calldata params)
611
        external
612
        returns (bytes memory data);
613

                            
                        
614
    /// Records the debug trace during the run.
615
    function startDebugTraceRecording() external;
616

                            
                        
617
    /// Starts recording all map SSTOREs for later retrieval.
618
    function startMappingRecording() external;
619

                            
                        
620
    /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,
621
    /// along with the context of the calls
622
    function startStateDiffRecording() external;
623

                            
                        
624
    /// Stop debug trace recording and returns the recorded debug trace.
625
    function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);
626

                            
                        
627
    /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.
628
    function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);
629

                            
                        
630
    /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.
631
    function stopMappingRecording() external;
632

                            
                        
633
    // ======== Filesystem ========
634

                            
                        
635
    /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
636
    /// `path` is relative to the project root.
637
    function closeFile(string calldata path) external;
638

                            
                        
639
    /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.
640
    /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.
641
    /// Both `from` and `to` are relative to the project root.
642
    function copyFile(string calldata from, string calldata to) external returns (uint64 copied);
643

                            
                        
644
    /// Creates a new, empty directory at the provided path.
645
    /// This cheatcode will revert in the following situations, but is not limited to just these cases:
646
    /// - User lacks permissions to modify `path`.
647
    /// - A parent of the given path doesn't exist and `recursive` is false.
648
    /// - `path` already exists and `recursive` is false.
649
    /// `path` is relative to the project root.
650
    function createDir(string calldata path, bool recursive) external;
651

                            
                        
652
    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
653
    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
654
    function deployCode(string calldata artifactPath) external returns (address deployedAddress);
655

                            
                        
656
    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
657
    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
658
    /// Additionally accepts abi-encoded constructor arguments.
659
    function deployCode(string calldata artifactPath, bytes calldata constructorArgs)
660
        external
661
        returns (address deployedAddress);
662

                            
                        
663
    /// Returns true if the given path points to an existing entity, else returns false.
664
    function exists(string calldata path) external returns (bool result);
665

                            
                        
666
    /// Performs a foreign function call via the terminal.
667
    function ffi(string[] calldata commandInput) external returns (bytes memory result);
668

                            
                        
669
    /// Given a path, query the file system to get information about a file, directory, etc.
670
    function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);
671

                            
                        
672
    /// Gets the artifact path from code (aka. creation code).
673
    function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);
674

                            
                        
675
    /// Gets the artifact path from deployed code (aka. runtime code).
676
    function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);
677

                            
                        
678
    /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the
679
    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
680
    function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);
681

                            
                        
682
    /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the
683
    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
684
    function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);
685

                            
                        
686
    /// Returns true if the path exists on disk and is pointing at a directory, else returns false.
687
    function isDir(string calldata path) external returns (bool result);
688

                            
                        
689
    /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.
690
    function isFile(string calldata path) external returns (bool result);
691

                            
                        
692
    /// Get the path of the current project root.
693
    function projectRoot() external view returns (string memory path);
694

                            
                        
695
    /// Prompts the user for a string value in the terminal.
696
    function prompt(string calldata promptText) external returns (string memory input);
697

                            
                        
698
    /// Prompts the user for an address in the terminal.
699
    function promptAddress(string calldata promptText) external returns (address);
700

                            
                        
701
    /// Prompts the user for a hidden string value in the terminal.
702
    function promptSecret(string calldata promptText) external returns (string memory input);
703

                            
                        
704
    /// Prompts the user for hidden uint256 in the terminal (usually pk).
705
    function promptSecretUint(string calldata promptText) external returns (uint256);
706

                            
                        
707
    /// Prompts the user for uint256 in the terminal.
708
    function promptUint(string calldata promptText) external returns (uint256);
709

                            
                        
710
    /// Reads the directory at the given path recursively, up to `maxDepth`.
711
    /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.
712
    /// Follows symbolic links if `followLinks` is true.
713
    function readDir(string calldata path) external view returns (DirEntry[] memory entries);
714

                            
                        
715
    /// See `readDir(string)`.
716
    function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);
717

                            
                        
718
    /// See `readDir(string)`.
719
    function readDir(string calldata path, uint64 maxDepth, bool followLinks)
720
        external
721
        view
722
        returns (DirEntry[] memory entries);
723

                            
                        
724
    /// Reads the entire content of file to string. `path` is relative to the project root.
725
    function readFile(string calldata path) external view returns (string memory data);
726

                            
                        
727
    /// Reads the entire content of file as binary. `path` is relative to the project root.
728
    function readFileBinary(string calldata path) external view returns (bytes memory data);
729

                            
                        
730
    /// Reads next line of file to string.
731
    function readLine(string calldata path) external view returns (string memory line);
732

                            
                        
733
    /// Reads a symbolic link, returning the path that the link points to.
734
    /// This cheatcode will revert in the following situations, but is not limited to just these cases:
735
    /// - `path` is not a symbolic link.
736
    /// - `path` does not exist.
737
    function readLink(string calldata linkPath) external view returns (string memory targetPath);
738

                            
                        
739
    /// Removes a directory at the provided path.
740
    /// This cheatcode will revert in the following situations, but is not limited to just these cases:
741
    /// - `path` doesn't exist.
742
    /// - `path` isn't a directory.
743
    /// - User lacks permissions to modify `path`.
744
    /// - The directory is not empty and `recursive` is false.
745
    /// `path` is relative to the project root.
746
    function removeDir(string calldata path, bool recursive) external;
747

                            
                        
748
    /// Removes a file from the filesystem.
749
    /// This cheatcode will revert in the following situations, but is not limited to just these cases:
750
    /// - `path` points to a directory.
751
    /// - The file doesn't exist.
752
    /// - The user lacks permissions to remove the file.
753
    /// `path` is relative to the project root.
754
    function removeFile(string calldata path) external;
755

                            
                        
756
    /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.
757
    function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);
758

                            
                        
759
    /// Returns the time since unix epoch in milliseconds.
760
    function unixTime() external returns (uint256 milliseconds);
761

                            
                        
762
    /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
763
    /// `path` is relative to the project root.
764
    function writeFile(string calldata path, string calldata data) external;
765

                            
                        
766
    /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.
767
    /// `path` is relative to the project root.
768
    function writeFileBinary(string calldata path, bytes calldata data) external;
769

                            
                        
770
    /// Writes line to file, creating a file if it does not exist.
771
    /// `path` is relative to the project root.
772
    function writeLine(string calldata path, string calldata data) external;
773

                            
                        
774
    // ======== JSON ========
775

                            
                        
776
    /// Checks if `key` exists in a JSON object.
777
    function keyExistsJson(string calldata json, string calldata key) external view returns (bool);
778

                            
                        
779
    /// Parses a string of JSON data at `key` and coerces it to `address`.
780
    function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);
781

                            
                        
782
    /// Parses a string of JSON data at `key` and coerces it to `address[]`.
783
    function parseJsonAddressArray(string calldata json, string calldata key)
784
        external
785
        pure
786
        returns (address[] memory);
787

                            
                        
788
    /// Parses a string of JSON data at `key` and coerces it to `bool`.
789
    function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);
790

                            
                        
791
    /// Parses a string of JSON data at `key` and coerces it to `bool[]`.
792
    function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);
793

                            
                        
794
    /// Parses a string of JSON data at `key` and coerces it to `bytes`.
795
    function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);
796

                            
                        
797
    /// Parses a string of JSON data at `key` and coerces it to `bytes32`.
798
    function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);
799

                            
                        
800
    /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.
801
    function parseJsonBytes32Array(string calldata json, string calldata key)
802
        external
803
        pure
804
        returns (bytes32[] memory);
805

                            
                        
806
    /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.
807
    function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);
808

                            
                        
809
    /// Parses a string of JSON data at `key` and coerces it to `int256`.
810
    function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);
811

                            
                        
812
    /// Parses a string of JSON data at `key` and coerces it to `int256[]`.
813
    function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);
814

                            
                        
815
    /// Returns an array of all the keys in a JSON object.
816
    function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);
817

                            
                        
818
    /// Parses a string of JSON data at `key` and coerces it to `string`.
819
    function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);
820

                            
                        
821
    /// Parses a string of JSON data at `key` and coerces it to `string[]`.
822
    function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);
823

                            
                        
824
    /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.
825
    function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
826
        external
827
        pure
828
        returns (bytes memory);
829

                            
                        
830
    /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.
831
    function parseJsonType(string calldata json, string calldata typeDescription)
832
        external
833
        pure
834
        returns (bytes memory);
835

                            
                        
836
    /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.
837
    function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)
838
        external
839
        pure
840
        returns (bytes memory);
841

                            
                        
842
    /// Parses a string of JSON data at `key` and coerces it to `uint256`.
843
    function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);
844

                            
                        
845
    /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.
846
    function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);
847

                            
                        
848
    /// ABI-encodes a JSON object.
849
    function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);
850

                            
                        
851
    /// ABI-encodes a JSON object at `key`.
852
    function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);
853

                            
                        
854
    /// See `serializeJson`.
855
    function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
856
        external
857
        returns (string memory json);
858

                            
                        
859
    /// See `serializeJson`.
860
    function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
861
        external
862
        returns (string memory json);
863

                            
                        
864
    /// See `serializeJson`.
865
    function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
866
        external
867
        returns (string memory json);
868

                            
                        
869
    /// See `serializeJson`.
870
    function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
871
        external
872
        returns (string memory json);
873

                            
                        
874
    /// See `serializeJson`.
875
    function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
876
        external
877
        returns (string memory json);
878

                            
                        
879
    /// See `serializeJson`.
880
    function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
881
        external
882
        returns (string memory json);
883

                            
                        
884
    /// See `serializeJson`.
885
    function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
886
        external
887
        returns (string memory json);
888

                            
                        
889
    /// See `serializeJson`.
890
    function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
891
        external
892
        returns (string memory json);
893

                            
                        
894
    /// See `serializeJson`.
895
    function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
896
        external
897
        returns (string memory json);
898

                            
                        
899
    /// See `serializeJson`.
900
    function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
901
        external
902
        returns (string memory json);
903

                            
                        
904
    /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.
905
    /// Returns the stringified version of the specific JSON file up to that moment.
906
    function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);
907

                            
                        
908
    /// See `serializeJson`.
909
    function serializeJsonType(string calldata typeDescription, bytes calldata value)
910
        external
911
        pure
912
        returns (string memory json);
913

                            
                        
914
    /// See `serializeJson`.
915
    function serializeJsonType(
916
        string calldata objectKey,
917
        string calldata valueKey,
918
        string calldata typeDescription,
919
        bytes calldata value
920
    ) external returns (string memory json);
921

                            
                        
922
    /// See `serializeJson`.
923
    function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
924
        external
925
        returns (string memory json);
926

                            
                        
927
    /// See `serializeJson`.
928
    function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
929
        external
930
        returns (string memory json);
931

                            
                        
932
    /// See `serializeJson`.
933
    function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)
934
        external
935
        returns (string memory json);
936

                            
                        
937
    /// See `serializeJson`.
938
    function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
939
        external
940
        returns (string memory json);
941

                            
                        
942
    /// See `serializeJson`.
943
    function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
944
        external
945
        returns (string memory json);
946

                            
                        
947
    /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
948
    function writeJson(string calldata json, string calldata path) external;
949

                            
                        
950
    /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.>
951
    /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.
952
    function writeJson(string calldata json, string calldata path, string calldata valueKey) external;
953

                            
                        
954
    /// Checks if `key` exists in a JSON object
955
    /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.
956
    function keyExists(string calldata json, string calldata key) external view returns (bool);
957

                            
                        
958
    // ======== Scripting ========
959

                            
                        
960
    /// Takes a signed transaction and broadcasts it to the network.
961
    function broadcastRawTransaction(bytes calldata data) external;
962

                            
                        
963
    /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.
964
    /// Broadcasting address is determined by checking the following in order:
965
    /// 1. If `--sender` argument was provided, that address is used.
966
    /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
967
    /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
968
    function broadcast() external;
969

                            
                        
970
    /// Has the next call (at this call depth only) create a transaction with the address provided
971
    /// as the sender that can later be signed and sent onchain.
972
    function broadcast(address signer) external;
973

                            
                        
974
    /// Has the next call (at this call depth only) create a transaction with the private key
975
    /// provided as the sender that can later be signed and sent onchain.
976
    function broadcast(uint256 privateKey) external;
977

                            
                        
978
    /// Returns addresses of available unlocked wallets in the script environment.
979
    function getScriptWallets() external returns (address[] memory wallets);
980

                            
                        
981
    /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.
982
    /// Broadcasting address is determined by checking the following in order:
983
    /// 1. If `--sender` argument was provided, that address is used.
984
    /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
985
    /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
986
    function startBroadcast() external;
987

                            
                        
988
    /// Has all subsequent calls (at this call depth only) create transactions with the address
989
    /// provided that can later be signed and sent onchain.
990
    function startBroadcast(address signer) external;
991

                            
                        
992
    /// Has all subsequent calls (at this call depth only) create transactions with the private key
993
    /// provided that can later be signed and sent onchain.
994
    function startBroadcast(uint256 privateKey) external;
995

                            
                        
996
    /// Stops collecting onchain transactions.
997
    function stopBroadcast() external;
998

                            
                        
999
    /// Returns addresses of available unlocked wallets in the script environment.
1000
    function getWallets() external returns (address[] memory wallets);
1001

                            
                        
1002
    // ======== String ========
1003

                            
                        
1004
    /// Returns the index of the first occurrence of a `key` in an `input` string.
1005
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.
1006
    /// Returns 0 in case of an empty `key`.
1007
    function indexOf(string calldata input, string calldata key) external pure returns (uint256);
1008

                            
                        
1009
    /// Parses the given `string` into an `address`.
1010
    function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);
1011

                            
                        
1012
    /// Parses the given `string` into a `bool`.
1013
    function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
1014

                            
                        
1015
    /// Parses the given `string` into `bytes`.
1016
    function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);
1017

                            
                        
1018
    /// Parses the given `string` into a `bytes32`.
1019
    function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);
1020

                            
                        
1021
    /// Parses the given `string` into a `int256`.
1022
    function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);
1023

                            
                        
1024
    /// Parses the given `string` into a `uint256`.
1025
    function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);
1026

                            
                        
1027
    /// Replaces occurrences of `from` in the given `string` with `to`.
1028
    function replace(string calldata input, string calldata from, string calldata to)
1029
        external
1030
        pure
1031
        returns (string memory output);
1032

                            
                        
1033
    /// Splits the given `string` into an array of strings divided by the `delimiter`.
1034
    function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);
1035

                            
                        
1036
    /// Converts the given `string` value to Lowercase.
1037
    function toLowercase(string calldata input) external pure returns (string memory output);
1038

                            
                        
1039
    /// Converts the given value to a `string`.
1040
    function toString(address value) external pure returns (string memory stringifiedValue);
1041

                            
                        
1042
    /// Converts the given value to a `string`.
1043
    function toString(bytes calldata value) external pure returns (string memory stringifiedValue);
1044

                            
                        
1045
    /// Converts the given value to a `string`.
1046
    function toString(bytes32 value) external pure returns (string memory stringifiedValue);
1047

                            
                        
1048
    /// Converts the given value to a `string`.
1049
    function toString(bool value) external pure returns (string memory stringifiedValue);
1050

                            
                        
1051
    /// Converts the given value to a `string`.
1052
    function toString(uint256 value) external pure returns (string memory stringifiedValue);
1053

                            
                        
1054
    /// Converts the given value to a `string`.
1055
    function toString(int256 value) external pure returns (string memory stringifiedValue);
1056

                            
                        
1057
    /// Converts the given `string` value to Uppercase.
1058
    function toUppercase(string calldata input) external pure returns (string memory output);
1059

                            
                        
1060
    /// Trims leading and trailing whitespace from the given `string` value.
1061
    function trim(string calldata input) external pure returns (string memory output);
1062

                            
                        
1063
    // ======== Testing ========
1064

                            
                        
1065
    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
1066
    /// Formats values with decimals in failure message.
1067
    function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;
1068

                            
                        
1069
    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
1070
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1071
    function assertApproxEqAbsDecimal(
1072
        uint256 left,
1073
        uint256 right,
1074
        uint256 maxDelta,
1075
        uint256 decimals,
1076
        string calldata error
1077
    ) external pure;
1078

                            
                        
1079
    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
1080
    /// Formats values with decimals in failure message.
1081
    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;
1082

                            
                        
1083
    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
1084
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1085
    function assertApproxEqAbsDecimal(
1086
        int256 left,
1087
        int256 right,
1088
        uint256 maxDelta,
1089
        uint256 decimals,
1090
        string calldata error
1091
    ) external pure;
1092

                            
                        
1093
    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
1094
    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;
1095

                            
                        
1096
    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
1097
    /// Includes error message into revert string on failure.
1098
    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;
1099

                            
                        
1100
    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
1101
    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;
1102

                            
                        
1103
    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
1104
    /// Includes error message into revert string on failure.
1105
    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;
1106

                            
                        
1107
    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1108
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1109
    /// Formats values with decimals in failure message.
1110
    function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
1111
        external
1112
        pure;
1113

                            
                        
1114
    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1115
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1116
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1117
    function assertApproxEqRelDecimal(
1118
        uint256 left,
1119
        uint256 right,
1120
        uint256 maxPercentDelta,
1121
        uint256 decimals,
1122
        string calldata error
1123
    ) external pure;
1124

                            
                        
1125
    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1126
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1127
    /// Formats values with decimals in failure message.
1128
    function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)
1129
        external
1130
        pure;
1131

                            
                        
1132
    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1133
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1134
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1135
    function assertApproxEqRelDecimal(
1136
        int256 left,
1137
        int256 right,
1138
        uint256 maxPercentDelta,
1139
        uint256 decimals,
1140
        string calldata error
1141
    ) external pure;
1142

                            
                        
1143
    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1144
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1145
    function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;
1146

                            
                        
1147
    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1148
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1149
    /// Includes error message into revert string on failure.
1150
    function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)
1151
        external
1152
        pure;
1153

                            
                        
1154
    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1155
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1156
    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;
1157

                            
                        
1158
    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
1159
    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
1160
    /// Includes error message into revert string on failure.
1161
    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)
1162
        external
1163
        pure;
1164

                            
                        
1165
    /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
1166
    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1167

                            
                        
1168
    /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
1169
    /// Includes error message into revert string on failure.
1170
    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1171

                            
                        
1172
    /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
1173
    function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
1174

                            
                        
1175
    /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
1176
    /// Includes error message into revert string on failure.
1177
    function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1178

                            
                        
1179
    /// Asserts that two `bool` values are equal.
1180
    function assertEq(bool left, bool right) external pure;
1181

                            
                        
1182
    /// Asserts that two `bool` values are equal and includes error message into revert string on failure.
1183
    function assertEq(bool left, bool right, string calldata error) external pure;
1184

                            
                        
1185
    /// Asserts that two `string` values are equal.
1186
    function assertEq(string calldata left, string calldata right) external pure;
1187

                            
                        
1188
    /// Asserts that two `string` values are equal and includes error message into revert string on failure.
1189
    function assertEq(string calldata left, string calldata right, string calldata error) external pure;
1190

                            
                        
1191
    /// Asserts that two `bytes` values are equal.
1192
    function assertEq(bytes calldata left, bytes calldata right) external pure;
1193

                            
                        
1194
    /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.
1195
    function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
1196

                            
                        
1197
    /// Asserts that two arrays of `bool` values are equal.
1198
    function assertEq(bool[] calldata left, bool[] calldata right) external pure;
1199

                            
                        
1200
    /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.
1201
    function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
1202

                            
                        
1203
    /// Asserts that two arrays of `uint256 values are equal.
1204
    function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;
1205

                            
                        
1206
    /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.
1207
    function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
1208

                            
                        
1209
    /// Asserts that two arrays of `int256` values are equal.
1210
    function assertEq(int256[] calldata left, int256[] calldata right) external pure;
1211

                            
                        
1212
    /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.
1213
    function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
1214

                            
                        
1215
    /// Asserts that two `uint256` values are equal.
1216
    function assertEq(uint256 left, uint256 right) external pure;
1217

                            
                        
1218
    /// Asserts that two arrays of `address` values are equal.
1219
    function assertEq(address[] calldata left, address[] calldata right) external pure;
1220

                            
                        
1221
    /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.
1222
    function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
1223

                            
                        
1224
    /// Asserts that two arrays of `bytes32` values are equal.
1225
    function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
1226

                            
                        
1227
    /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.
1228
    function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
1229

                            
                        
1230
    /// Asserts that two arrays of `string` values are equal.
1231
    function assertEq(string[] calldata left, string[] calldata right) external pure;
1232

                            
                        
1233
    /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.
1234
    function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
1235

                            
                        
1236
    /// Asserts that two arrays of `bytes` values are equal.
1237
    function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;
1238

                            
                        
1239
    /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.
1240
    function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
1241

                            
                        
1242
    /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.
1243
    function assertEq(uint256 left, uint256 right, string calldata error) external pure;
1244

                            
                        
1245
    /// Asserts that two `int256` values are equal.
1246
    function assertEq(int256 left, int256 right) external pure;
1247

                            
                        
1248
    /// Asserts that two `int256` values are equal and includes error message into revert string on failure.
1249
    function assertEq(int256 left, int256 right, string calldata error) external pure;
1250

                            
                        
1251
    /// Asserts that two `address` values are equal.
1252
    function assertEq(address left, address right) external pure;
1253

                            
                        
1254
    /// Asserts that two `address` values are equal and includes error message into revert string on failure.
1255
    function assertEq(address left, address right, string calldata error) external pure;
1256

                            
                        
1257
    /// Asserts that two `bytes32` values are equal.
1258
    function assertEq(bytes32 left, bytes32 right) external pure;
1259

                            
                        
1260
    /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.
1261
    function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;
1262

                            
                        
1263
    /// Asserts that the given condition is false.
1264
    function assertFalse(bool condition) external pure;
1265

                            
                        
1266
    /// Asserts that the given condition is false and includes error message into revert string on failure.
1267
    function assertFalse(bool condition, string calldata error) external pure;
1268

                            
                        
1269
    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
1270
    /// Formats values with decimals in failure message.
1271
    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1272

                            
                        
1273
    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
1274
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1275
    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1276

                            
                        
1277
    /// Compares two `int256` values. Expects first value to be greater than or equal to second.
1278
    /// Formats values with decimals in failure message.
1279
    function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;
1280

                            
                        
1281
    /// Compares two `int256` values. Expects first value to be greater than or equal to second.
1282
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1283
    function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1284

                            
                        
1285
    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
1286
    function assertGe(uint256 left, uint256 right) external pure;
1287

                            
                        
1288
    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
1289
    /// Includes error message into revert string on failure.
1290
    function assertGe(uint256 left, uint256 right, string calldata error) external pure;
1291

                            
                        
1292
    /// Compares two `int256` values. Expects first value to be greater than or equal to second.
1293
    function assertGe(int256 left, int256 right) external pure;
1294

                            
                        
1295
    /// Compares two `int256` values. Expects first value to be greater than or equal to second.
1296
    /// Includes error message into revert string on failure.
1297
    function assertGe(int256 left, int256 right, string calldata error) external pure;
1298

                            
                        
1299
    /// Compares two `uint256` values. Expects first value to be greater than second.
1300
    /// Formats values with decimals in failure message.
1301
    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1302

                            
                        
1303
    /// Compares two `uint256` values. Expects first value to be greater than second.
1304
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1305
    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1306

                            
                        
1307
    /// Compares two `int256` values. Expects first value to be greater than second.
1308
    /// Formats values with decimals in failure message.
1309
    function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;
1310

                            
                        
1311
    /// Compares two `int256` values. Expects first value to be greater than second.
1312
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1313
    function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1314

                            
                        
1315
    /// Compares two `uint256` values. Expects first value to be greater than second.
1316
    function assertGt(uint256 left, uint256 right) external pure;
1317

                            
                        
1318
    /// Compares two `uint256` values. Expects first value to be greater than second.
1319
    /// Includes error message into revert string on failure.
1320
    function assertGt(uint256 left, uint256 right, string calldata error) external pure;
1321

                            
                        
1322
    /// Compares two `int256` values. Expects first value to be greater than second.
1323
    function assertGt(int256 left, int256 right) external pure;
1324

                            
                        
1325
    /// Compares two `int256` values. Expects first value to be greater than second.
1326
    /// Includes error message into revert string on failure.
1327
    function assertGt(int256 left, int256 right, string calldata error) external pure;
1328

                            
                        
1329
    /// Compares two `uint256` values. Expects first value to be less than or equal to second.
1330
    /// Formats values with decimals in failure message.
1331
    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1332

                            
                        
1333
    /// Compares two `uint256` values. Expects first value to be less than or equal to second.
1334
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1335
    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1336

                            
                        
1337
    /// Compares two `int256` values. Expects first value to be less than or equal to second.
1338
    /// Formats values with decimals in failure message.
1339
    function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;
1340

                            
                        
1341
    /// Compares two `int256` values. Expects first value to be less than or equal to second.
1342
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1343
    function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1344

                            
                        
1345
    /// Compares two `uint256` values. Expects first value to be less than or equal to second.
1346
    function assertLe(uint256 left, uint256 right) external pure;
1347

                            
                        
1348
    /// Compares two `uint256` values. Expects first value to be less than or equal to second.
1349
    /// Includes error message into revert string on failure.
1350
    function assertLe(uint256 left, uint256 right, string calldata error) external pure;
1351

                            
                        
1352
    /// Compares two `int256` values. Expects first value to be less than or equal to second.
1353
    function assertLe(int256 left, int256 right) external pure;
1354

                            
                        
1355
    /// Compares two `int256` values. Expects first value to be less than or equal to second.
1356
    /// Includes error message into revert string on failure.
1357
    function assertLe(int256 left, int256 right, string calldata error) external pure;
1358

                            
                        
1359
    /// Compares two `uint256` values. Expects first value to be less than second.
1360
    /// Formats values with decimals in failure message.
1361
    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1362

                            
                        
1363
    /// Compares two `uint256` values. Expects first value to be less than second.
1364
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1365
    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1366

                            
                        
1367
    /// Compares two `int256` values. Expects first value to be less than second.
1368
    /// Formats values with decimals in failure message.
1369
    function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;
1370

                            
                        
1371
    /// Compares two `int256` values. Expects first value to be less than second.
1372
    /// Formats values with decimals in failure message. Includes error message into revert string on failure.
1373
    function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1374

                            
                        
1375
    /// Compares two `uint256` values. Expects first value to be less than second.
1376
    function assertLt(uint256 left, uint256 right) external pure;
1377

                            
                        
1378
    /// Compares two `uint256` values. Expects first value to be less than second.
1379
    /// Includes error message into revert string on failure.
1380
    function assertLt(uint256 left, uint256 right, string calldata error) external pure;
1381

                            
                        
1382
    /// Compares two `int256` values. Expects first value to be less than second.
1383
    function assertLt(int256 left, int256 right) external pure;
1384

                            
                        
1385
    /// Compares two `int256` values. Expects first value to be less than second.
1386
    /// Includes error message into revert string on failure.
1387
    function assertLt(int256 left, int256 right, string calldata error) external pure;
1388

                            
                        
1389
    /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
1390
    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
1391

                            
                        
1392
    /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
1393
    /// Includes error message into revert string on failure.
1394
    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
1395

                            
                        
1396
    /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
1397
    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
1398

                            
                        
1399
    /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
1400
    /// Includes error message into revert string on failure.
1401
    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
1402

                            
                        
1403
    /// Asserts that two `bool` values are not equal.
1404
    function assertNotEq(bool left, bool right) external pure;
1405

                            
                        
1406
    /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.
1407
    function assertNotEq(bool left, bool right, string calldata error) external pure;
1408

                            
                        
1409
    /// Asserts that two `string` values are not equal.
1410
    function assertNotEq(string calldata left, string calldata right) external pure;
1411

                            
                        
1412
    /// Asserts that two `string` values are not equal and includes error message into revert string on failure.
1413
    function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;
1414

                            
                        
1415
    /// Asserts that two `bytes` values are not equal.
1416
    function assertNotEq(bytes calldata left, bytes calldata right) external pure;
1417

                            
                        
1418
    /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.
1419
    function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
1420

                            
                        
1421
    /// Asserts that two arrays of `bool` values are not equal.
1422
    function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;
1423

                            
                        
1424
    /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.
1425
    function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
1426

                            
                        
1427
    /// Asserts that two arrays of `uint256` values are not equal.
1428
    function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;
1429

                            
                        
1430
    /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.
1431
    function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
1432

                            
                        
1433
    /// Asserts that two arrays of `int256` values are not equal.
1434
    function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;
1435

                            
                        
1436
    /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.
1437
    function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
1438

                            
                        
1439
    /// Asserts that two `uint256` values are not equal.
1440
    function assertNotEq(uint256 left, uint256 right) external pure;
1441

                            
                        
1442
    /// Asserts that two arrays of `address` values are not equal.
1443
    function assertNotEq(address[] calldata left, address[] calldata right) external pure;
1444

                            
                        
1445
    /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.
1446
    function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
1447

                            
                        
1448
    /// Asserts that two arrays of `bytes32` values are not equal.
1449
    function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
1450

                            
                        
1451
    /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.
1452
    function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
1453

                            
                        
1454
    /// Asserts that two arrays of `string` values are not equal.
1455
    function assertNotEq(string[] calldata left, string[] calldata right) external pure;
1456

                            
                        
1457
    /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.
1458
    function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
1459

                            
                        
1460
    /// Asserts that two arrays of `bytes` values are not equal.
1461
    function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;
1462

                            
                        
1463
    /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.
1464
    function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
1465

                            
                        
1466
    /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.
1467
    function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;
1468

                            
                        
1469
    /// Asserts that two `int256` values are not equal.
1470
    function assertNotEq(int256 left, int256 right) external pure;
1471

                            
                        
1472
    /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.
1473
    function assertNotEq(int256 left, int256 right, string calldata error) external pure;
1474

                            
                        
1475
    /// Asserts that two `address` values are not equal.
1476
    function assertNotEq(address left, address right) external pure;
1477

                            
                        
1478
    /// Asserts that two `address` values are not equal and includes error message into revert string on failure.
1479
    function assertNotEq(address left, address right, string calldata error) external pure;
1480

                            
                        
1481
    /// Asserts that two `bytes32` values are not equal.
1482
    function assertNotEq(bytes32 left, bytes32 right) external pure;
1483

                            
                        
1484
    /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.
1485
    function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;
1486

                            
                        
1487
    /// Asserts that the given condition is true.
1488
    function assertTrue(bool condition) external pure;
1489

                            
                        
1490
    /// Asserts that the given condition is true and includes error message into revert string on failure.
1491
    function assertTrue(bool condition, string calldata error) external pure;
1492

                            
                        
1493
    /// If the condition is false, discard this run's fuzz inputs and generate new ones.
1494
    function assume(bool condition) external pure;
1495

                            
                        
1496
    /// Discard this run's fuzz inputs and generate new ones if next call reverted.
1497
    function assumeNoRevert() external pure;
1498

                            
                        
1499
    /// Writes a breakpoint to jump to in the debugger.
1500
    function breakpoint(string calldata char) external pure;
1501

                            
                        
1502
    /// Writes a conditional breakpoint to jump to in the debugger.
1503
    function breakpoint(string calldata char, bool value) external pure;
1504

                            
                        
1505
    /// Returns the Foundry version.
1506
    /// Format: <cargo_version>+<git_sha>+<build_timestamp>
1507
    /// Sample output: 0.2.0+faa94c384+202407110019
1508
    /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.
1509
    /// For reliable version comparisons, use YYYYMMDD0000 format (e.g., >= 202407110000)
1510
    /// to compare timestamps while ignoring minor time differences.
1511
    function getFoundryVersion() external view returns (string memory version);
1512

                            
                        
1513
    /// Returns the RPC url for the given alias.
1514
    function rpcUrl(string calldata rpcAlias) external view returns (string memory json);
1515

                            
                        
1516
    /// Returns all rpc urls and their aliases as structs.
1517
    function rpcUrlStructs() external view returns (Rpc[] memory urls);
1518

                            
                        
1519
    /// Returns all rpc urls and their aliases `[alias, url][]`.
1520
    function rpcUrls() external view returns (string[2][] memory urls);
1521

                            
                        
1522
    /// Suspends execution of the main thread for `duration` milliseconds.
1523
    function sleep(uint256 duration) external;
1524

                            
                        
1525
    // ======== Toml ========
1526

                            
                        
1527
    /// Checks if `key` exists in a TOML table.
1528
    function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);
1529

                            
                        
1530
    /// Parses a string of TOML data at `key` and coerces it to `address`.
1531
    function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);
1532

                            
                        
1533
    /// Parses a string of TOML data at `key` and coerces it to `address[]`.
1534
    function parseTomlAddressArray(string calldata toml, string calldata key)
1535
        external
1536
        pure
1537
        returns (address[] memory);
1538

                            
                        
1539
    /// Parses a string of TOML data at `key` and coerces it to `bool`.
1540
    function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);
1541

                            
                        
1542
    /// Parses a string of TOML data at `key` and coerces it to `bool[]`.
1543
    function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);
1544

                            
                        
1545
    /// Parses a string of TOML data at `key` and coerces it to `bytes`.
1546
    function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);
1547

                            
                        
1548
    /// Parses a string of TOML data at `key` and coerces it to `bytes32`.
1549
    function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);
1550

                            
                        
1551
    /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.
1552
    function parseTomlBytes32Array(string calldata toml, string calldata key)
1553
        external
1554
        pure
1555
        returns (bytes32[] memory);
1556

                            
                        
1557
    /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.
1558
    function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);
1559

                            
                        
1560
    /// Parses a string of TOML data at `key` and coerces it to `int256`.
1561
    function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);
1562

                            
                        
1563
    /// Parses a string of TOML data at `key` and coerces it to `int256[]`.
1564
    function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);
1565

                            
                        
1566
    /// Returns an array of all the keys in a TOML table.
1567
    function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);
1568

                            
                        
1569
    /// Parses a string of TOML data at `key` and coerces it to `string`.
1570
    function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);
1571

                            
                        
1572
    /// Parses a string of TOML data at `key` and coerces it to `string[]`.
1573
    function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);
1574

                            
                        
1575
    /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.
1576
    function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)
1577
        external
1578
        pure
1579
        returns (bytes memory);
1580

                            
                        
1581
    /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.
1582
    function parseTomlType(string calldata toml, string calldata typeDescription)
1583
        external
1584
        pure
1585
        returns (bytes memory);
1586

                            
                        
1587
    /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.
1588
    function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)
1589
        external
1590
        pure
1591
        returns (bytes memory);
1592

                            
                        
1593
    /// Parses a string of TOML data at `key` and coerces it to `uint256`.
1594
    function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);
1595

                            
                        
1596
    /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.
1597
    function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);
1598

                            
                        
1599
    /// ABI-encodes a TOML table.
1600
    function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);
1601

                            
                        
1602
    /// ABI-encodes a TOML table at `key`.
1603
    function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);
1604

                            
                        
1605
    /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.
1606
    function writeToml(string calldata json, string calldata path) external;
1607

                            
                        
1608
    /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = <value_key.>
1609
    /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.
1610
    function writeToml(string calldata json, string calldata path, string calldata valueKey) external;
1611

                            
                        
1612
    // ======== Utilities ========
1613

                            
                        
1614
    /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.
1615
    function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)
1616
        external
1617
        pure
1618
        returns (address);
1619

                            
                        
1620
    /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.
1621
    function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);
1622

                            
                        
1623
    /// Compute the address a contract will be deployed at for a given deployer address and nonce.
1624
    function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);
1625

                            
                        
1626
    /// Utility cheatcode to copy storage of `from` contract to another `to` contract.
1627
    function copyStorage(address from, address to) external;
1628

                            
                        
1629
    /// Returns ENS namehash for provided string.
1630
    function ensNamehash(string calldata name) external pure returns (bytes32);
1631

                            
                        
1632
    /// Gets the label for the specified address.
1633
    function getLabel(address account) external view returns (string memory currentLabel);
1634

                            
                        
1635
    /// Labels an address in call traces.
1636
    function label(address account, string calldata newLabel) external;
1637

                            
                        
1638
    /// Pauses collection of call traces. Useful in cases when you want to skip tracing of
1639
    /// complex calls which are not useful for debugging.
1640
    function pauseTracing() external view;
1641

                            
                        
1642
    /// Returns a random `address`.
1643
    function randomAddress() external returns (address);
1644

                            
                        
1645
    /// Returns a random `bool`.
1646
    function randomBool() external view returns (bool);
1647

                            
                        
1648
    /// Returns a random byte array value of the given length.
1649
    function randomBytes(uint256 len) external view returns (bytes memory);
1650

                            
                        
1651
    /// Returns a random fixed-size byte array of length 4.
1652
    function randomBytes4() external view returns (bytes4);
1653

                            
                        
1654
    /// Returns a random fixed-size byte array of length 8.
1655
    function randomBytes8() external view returns (bytes8);
1656

                            
                        
1657
    /// Returns a random `int256` value.
1658
    function randomInt() external view returns (int256);
1659

                            
                        
1660
    /// Returns a random `int256` value of given bits.
1661
    function randomInt(uint256 bits) external view returns (int256);
1662

                            
                        
1663
    /// Returns a random uint256 value.
1664
    function randomUint() external returns (uint256);
1665

                            
                        
1666
    /// Returns random uint256 value between the provided range (=min..=max).
1667
    function randomUint(uint256 min, uint256 max) external returns (uint256);
1668

                            
                        
1669
    /// Returns a random `uint256` value of given bits.
1670
    function randomUint(uint256 bits) external view returns (uint256);
1671

                            
                        
1672
    /// Unpauses collection of call traces.
1673
    function resumeTracing() external view;
1674

                            
                        
1675
    /// Utility cheatcode to set arbitrary storage for given target address.
1676
    function setArbitraryStorage(address target) external;
1677

                            
                        
1678
    /// Encodes a `bytes` value to a base64url string.
1679
    function toBase64URL(bytes calldata data) external pure returns (string memory);
1680

                            
                        
1681
    /// Encodes a `string` value to a base64url string.
1682
    function toBase64URL(string calldata data) external pure returns (string memory);
1683

                            
                        
1684
    /// Encodes a `bytes` value to a base64 string.
1685
    function toBase64(bytes calldata data) external pure returns (string memory);
1686

                            
                        
1687
    /// Encodes a `string` value to a base64 string.
1688
    function toBase64(string calldata data) external pure returns (string memory);
1689
}
1690

                            
                        
1691
/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
1692
/// in tests, but it is not recommended to use these cheats in scripts.
1693
interface Vm is VmSafe {
1694
    // ======== EVM ========
1695

                            
                        
1696
    /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.
1697
    function activeFork() external view returns (uint256 forkId);
1698

                            
                        
1699
    /// In forking mode, explicitly grant the given address cheatcode access.
1700
    function allowCheatcodes(address account) external;
1701

                            
                        
1702
    /// Sets `block.blobbasefee`
1703
    function blobBaseFee(uint256 newBlobBaseFee) external;
1704

                            
                        
1705
    /// Sets the blobhashes in the transaction.
1706
    /// Not available on EVM versions before Cancun.
1707
    /// If used on unsupported EVM versions it will revert.
1708
    function blobhashes(bytes32[] calldata hashes) external;
1709

                            
                        
1710
    /// Sets `block.chainid`.
1711
    function chainId(uint256 newChainId) external;
1712

                            
                        
1713
    /// Clears all mocked calls.
1714
    function clearMockedCalls() external;
1715

                            
                        
1716
    /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.
1717
    function cloneAccount(address source, address target) external;
1718

                            
                        
1719
    /// Sets `block.coinbase`.
1720
    function coinbase(address newCoinbase) external;
1721

                            
                        
1722
    /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.
1723
    function createFork(string calldata urlOrAlias) external returns (uint256 forkId);
1724

                            
                        
1725
    /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.
1726
    function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
1727

                            
                        
1728
    /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,
1729
    /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.
1730
    function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
1731

                            
                        
1732
    /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.
1733
    function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);
1734

                            
                        
1735
    /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.
1736
    function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
1737

                            
                        
1738
    /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,
1739
    /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.
1740
    function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
1741

                            
                        
1742
    /// Sets an address' balance.
1743
    function deal(address account, uint256 newBalance) external;
1744

                            
                        
1745
    /// Removes the snapshot with the given ID created by `snapshot`.
1746
    /// Takes the snapshot ID to delete.
1747
    /// Returns `true` if the snapshot was successfully deleted.
1748
    /// Returns `false` if the snapshot does not exist.
1749
    function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);
1750

                            
                        
1751
    /// Removes _all_ snapshots previously created by `snapshot`.
1752
    function deleteStateSnapshots() external;
1753

                            
                        
1754
    /// Sets `block.difficulty`.
1755
    /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.
1756
    /// Reverts if used on unsupported EVM versions.
1757
    function difficulty(uint256 newDifficulty) external;
1758

                            
                        
1759
    /// Dump a genesis JSON file's `allocs` to disk.
1760
    function dumpState(string calldata pathToStateJson) external;
1761

                            
                        
1762
    /// Sets an address' code.
1763
    function etch(address target, bytes calldata newRuntimeBytecode) external;
1764

                            
                        
1765
    /// Sets `block.basefee`.
1766
    function fee(uint256 newBasefee) external;
1767

                            
                        
1768
    /// Gets the blockhashes from the current transaction.
1769
    /// Not available on EVM versions before Cancun.
1770
    /// If used on unsupported EVM versions it will revert.
1771
    function getBlobhashes() external view returns (bytes32[] memory hashes);
1772

                            
                        
1773
    /// Returns true if the account is marked as persistent.
1774
    function isPersistent(address account) external view returns (bool persistent);
1775

                            
                        
1776
    /// Load a genesis JSON file's `allocs` into the in-memory EVM state.
1777
    function loadAllocs(string calldata pathToAllocsJson) external;
1778

                            
                        
1779
    /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
1780
    /// Meaning, changes made to the state of this account will be kept when switching forks.
1781
    function makePersistent(address account) external;
1782

                            
                        
1783
    /// See `makePersistent(address)`.
1784
    function makePersistent(address account0, address account1) external;
1785

                            
                        
1786
    /// See `makePersistent(address)`.
1787
    function makePersistent(address account0, address account1, address account2) external;
1788

                            
                        
1789
    /// See `makePersistent(address)`.
1790
    function makePersistent(address[] calldata accounts) external;
1791

                            
                        
1792
    /// Reverts a call to an address with specified revert data.
1793
    function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;
1794

                            
                        
1795
    /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
1796
    function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)
1797
        external;
1798

                            
                        
1799
    /// Mocks a call to an address, returning specified data.
1800
    /// Calldata can either be strict or a partial match, e.g. if you only
1801
    /// pass a Solidity selector to the expected calldata, then the entire Solidity
1802
    /// function will be mocked.
1803
    function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;
1804

                            
                        
1805
    /// Mocks a call to an address with a specific `msg.value`, returning specified data.
1806
    /// Calldata match takes precedence over `msg.value` in case of ambiguity.
1807
    function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;
1808

                            
                        
1809
    /// Mocks multiple calls to an address, returning specified data for each call.
1810
    function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;
1811

                            
                        
1812
    /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.
1813
    function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;
1814

                            
                        
1815
    /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls
1816
    /// `target` with the same calldata. This functionality is similar to a delegate call made to
1817
    /// `target` contract from `callee`.
1818
    /// Can be used to substitute a call to a function with another implementation that captures
1819
    /// the primary logic of the original function but is easier to reason about.
1820
    /// If calldata is not a strict match then partial match by selector is attempted.
1821
    function mockFunction(address callee, address target, bytes calldata data) external;
1822

                            
                        
1823
    /// Sets the *next* call's `msg.sender` to be the input address.
1824
    function prank(address msgSender) external;
1825

                            
                        
1826
    /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
1827
    function prank(address msgSender, address txOrigin) external;
1828

                            
                        
1829
    /// Sets `block.prevrandao`.
1830
    /// Not available on EVM versions before Paris. Use `difficulty` instead.
1831
    /// If used on unsupported EVM versions it will revert.
1832
    function prevrandao(bytes32 newPrevrandao) external;
1833

                            
                        
1834
    /// Sets `block.prevrandao`.
1835
    /// Not available on EVM versions before Paris. Use `difficulty` instead.
1836
    /// If used on unsupported EVM versions it will revert.
1837
    function prevrandao(uint256 newPrevrandao) external;
1838

                            
                        
1839
    /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.
1840
    function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);
1841

                            
                        
1842
    /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.
1843
    function resetNonce(address account) external;
1844

                            
                        
1845
    /// Revert the state of the EVM to a previous snapshot
1846
    /// Takes the snapshot ID to revert to.
1847
    /// Returns `true` if the snapshot was successfully reverted.
1848
    /// Returns `false` if the snapshot does not exist.
1849
    /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.
1850
    function revertToState(uint256 snapshotId) external returns (bool success);
1851

                            
                        
1852
    /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots
1853
    /// Takes the snapshot ID to revert to.
1854
    /// Returns `true` if the snapshot was successfully reverted and deleted.
1855
    /// Returns `false` if the snapshot does not exist.
1856
    function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);
1857

                            
                        
1858
    /// Revokes persistent status from the address, previously added via `makePersistent`.
1859
    function revokePersistent(address account) external;
1860

                            
                        
1861
    /// See `revokePersistent(address)`.
1862
    function revokePersistent(address[] calldata accounts) external;
1863

                            
                        
1864
    /// Sets `block.height`.
1865
    function roll(uint256 newHeight) external;
1866

                            
                        
1867
    /// Updates the currently active fork to given block number
1868
    /// This is similar to `roll` but for the currently active fork.
1869
    function rollFork(uint256 blockNumber) external;
1870

                            
                        
1871
    /// Updates the currently active fork to given transaction. This will `rollFork` with the number
1872
    /// of the block the transaction was mined in and replays all transaction mined before it in the block.
1873
    function rollFork(bytes32 txHash) external;
1874

                            
                        
1875
    /// Updates the given fork to given block number.
1876
    function rollFork(uint256 forkId, uint256 blockNumber) external;
1877

                            
                        
1878
    /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.
1879
    function rollFork(uint256 forkId, bytes32 txHash) external;
1880

                            
                        
1881
    /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
1882
    function selectFork(uint256 forkId) external;
1883

                            
                        
1884
    /// Set blockhash for the current block.
1885
    /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.
1886
    function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;
1887

                            
                        
1888
    /// Sets the nonce of an account. Must be higher than the current nonce of the account.
1889
    function setNonce(address account, uint64 newNonce) external;
1890

                            
                        
1891
    /// Sets the nonce of an account to an arbitrary value.
1892
    function setNonceUnsafe(address account, uint64 newNonce) external;
1893

                            
                        
1894
    /// Snapshot capture the gas usage of the last call by name from the callee perspective.
1895
    function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);
1896

                            
                        
1897
    /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.
1898
    function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);
1899

                            
                        
1900
    /// Snapshot the current state of the evm.
1901
    /// Returns the ID of the snapshot that was created.
1902
    /// To revert a snapshot use `revertToState`.
1903
    function snapshotState() external returns (uint256 snapshotId);
1904

                            
                        
1905
    /// Snapshot capture an arbitrary numerical value by name.
1906
    /// The group name is derived from the contract name.
1907
    function snapshotValue(string calldata name, uint256 value) external;
1908

                            
                        
1909
    /// Snapshot capture an arbitrary numerical value by name in a group.
1910
    function snapshotValue(string calldata group, string calldata name, uint256 value) external;
1911

                            
                        
1912
    /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.
1913
    function startPrank(address msgSender) external;
1914

                            
                        
1915
    /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
1916
    function startPrank(address msgSender, address txOrigin) external;
1917

                            
                        
1918
    /// Start a snapshot capture of the current gas usage by name.
1919
    /// The group name is derived from the contract name.
1920
    function startSnapshotGas(string calldata name) external;
1921

                            
                        
1922
    /// Start a snapshot capture of the current gas usage by name in a group.
1923
    function startSnapshotGas(string calldata group, string calldata name) external;
1924

                            
                        
1925
    /// Resets subsequent calls' `msg.sender` to be `address(this)`.
1926
    function stopPrank() external;
1927

                            
                        
1928
    /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.
1929
    function stopSnapshotGas() external returns (uint256 gasUsed);
1930

                            
                        
1931
    /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.
1932
    /// The group name is derived from the contract name.
1933
    function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);
1934

                            
                        
1935
    /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.
1936
    function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);
1937

                            
                        
1938
    /// Stores a value to an address' storage slot.
1939
    function store(address target, bytes32 slot, bytes32 value) external;
1940

                            
                        
1941
    /// Fetches the given transaction from the active fork and executes it on the current state.
1942
    function transact(bytes32 txHash) external;
1943

                            
                        
1944
    /// Fetches the given transaction from the given fork and executes it on the current state.
1945
    function transact(uint256 forkId, bytes32 txHash) external;
1946

                            
                        
1947
    /// Sets `tx.gasprice`.
1948
    function txGasPrice(uint256 newGasPrice) external;
1949

                            
                        
1950
    /// Sets `block.timestamp`.
1951
    function warp(uint256 newTimestamp) external;
1952

                            
                        
1953
    /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.
1954
    function deleteSnapshot(uint256 snapshotId) external returns (bool success);
1955

                            
                        
1956
    /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.
1957
    function deleteSnapshots() external;
1958

                            
                        
1959
    /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.
1960
    function revertToAndDelete(uint256 snapshotId) external returns (bool success);
1961

                            
                        
1962
    /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.
1963
    function revertTo(uint256 snapshotId) external returns (bool success);
1964

                            
                        
1965
    /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.
1966
    function snapshot() external returns (uint256 snapshotId);
1967

                            
                        
1968
    // ======== Testing ========
1969

                            
                        
1970
    /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
1971
    function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;
1972

                            
                        
1973
    /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
1974
    function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)
1975
        external;
1976

                            
                        
1977
    /// Expects a call to an address with the specified calldata.
1978
    /// Calldata can either be a strict or a partial match.
1979
    function expectCall(address callee, bytes calldata data) external;
1980

                            
                        
1981
    /// Expects given number of calls to an address with the specified calldata.
1982
    function expectCall(address callee, bytes calldata data, uint64 count) external;
1983

                            
                        
1984
    /// Expects a call to an address with the specified `msg.value` and calldata.
1985
    function expectCall(address callee, uint256 msgValue, bytes calldata data) external;
1986

                            
                        
1987
    /// Expects given number of calls to an address with the specified `msg.value` and calldata.
1988
    function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;
1989

                            
                        
1990
    /// Expect a call to an address with the specified `msg.value`, gas, and calldata.
1991
    function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;
1992

                            
                        
1993
    /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.
1994
    function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;
1995

                            
                        
1996
    /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
1997
    /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
1998
    /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
1999
    function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)
2000
        external;
2001

                            
                        
2002
    /// Same as the previous method, but also checks supplied address against emitting contract.
2003
    function expectEmitAnonymous(
2004
        bool checkTopic0,
2005
        bool checkTopic1,
2006
        bool checkTopic2,
2007
        bool checkTopic3,
2008
        bool checkData,
2009
        address emitter
2010
    ) external;
2011

                            
                        
2012
    /// Prepare an expected anonymous log with all topic and data checks enabled.
2013
    /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
2014
    /// logs were emitted in the expected order with the expected topics and data.
2015
    function expectEmitAnonymous() external;
2016

                            
                        
2017
    /// Same as the previous method, but also checks supplied address against emitting contract.
2018
    function expectEmitAnonymous(address emitter) external;
2019

                            
                        
2020
    /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
2021
    /// Call this function, then emit an event, then call a function. Internally after the call, we check if
2022
    /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
2023
    function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;
2024

                            
                        
2025
    /// Same as the previous method, but also checks supplied address against emitting contract.
2026
    function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)
2027
        external;
2028

                            
                        
2029
    /// Prepare an expected log with all topic and data checks enabled.
2030
    /// Call this function, then emit an event, then call a function. Internally after the call, we check if
2031
    /// logs were emitted in the expected order with the expected topics and data.
2032
    function expectEmit() external;
2033

                            
                        
2034
    /// Same as the previous method, but also checks supplied address against emitting contract.
2035
    function expectEmit(address emitter) external;
2036

                            
                        
2037
    /// Expects an error on next call that starts with the revert data.
2038
    function expectPartialRevert(bytes4 revertData) external;
2039

                            
                        
2040
    /// Expects an error on next call to reverter address, that starts with the revert data.
2041
    function expectPartialRevert(bytes4 revertData, address reverter) external;
2042

                            
                        
2043
    /// Expects an error on next call with any revert data.
2044
    function expectRevert() external;
2045

                            
                        
2046
    /// Expects an error on next call that exactly matches the revert data.
2047
    function expectRevert(bytes4 revertData) external;
2048

                            
                        
2049
    /// Expects an error on next call that exactly matches the revert data.
2050
    function expectRevert(bytes calldata revertData) external;
2051

                            
                        
2052
    /// Expects an error with any revert data on next call to reverter address.
2053
    function expectRevert(address reverter) external;
2054

                            
                        
2055
    /// Expects an error from reverter address on next call, with any revert data.
2056
    function expectRevert(bytes4 revertData, address reverter) external;
2057

                            
                        
2058
    /// Expects an error from reverter address on next call, that exactly matches the revert data.
2059
    function expectRevert(bytes calldata revertData, address reverter) external;
2060

                            
                        
2061
    /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other
2062
    /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.
2063
    function expectSafeMemory(uint64 min, uint64 max) external;
2064

                            
                        
2065
    /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.
2066
    /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges
2067
    /// to the set.
2068
    function expectSafeMemoryCall(uint64 min, uint64 max) external;
2069

                            
                        
2070
    /// Marks a test as skipped. Must be called at the top level of a test.
2071
    function skip(bool skipTest) external;
2072

                            
                        
2073
    /// Marks a test as skipped with a reason. Must be called at the top level of a test.
2074
    function skip(bool skipTest, string calldata reason) external;
2075

                            
                        
2076
    /// Stops all safe memory expectation in the current subcontext.
2077
    function stopExpectSafeMemory() external;
2078
}
2079

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.4.22 <0.9.0;
3

                            
                        
4
library console {
5
    address constant CONSOLE_ADDRESS =
6
        0x000000000000000000636F6e736F6c652e6c6f67;
7

                            
                        
8
    function _sendLogPayloadImplementation(bytes memory payload) internal view {
9
        address consoleAddress = CONSOLE_ADDRESS;
10
        /// @solidity memory-safe-assembly
11
        assembly {
12
            pop(
13
                staticcall(
14
                    gas(),
15
                    consoleAddress,
16
                    add(payload, 32),
17
                    mload(payload),
18
                    0,
19
                    0
20
                )
21
            )
22
        }
23
    }
24

                            
                        
25
    function _castToPure(
26
      function(bytes memory) internal view fnIn
27
    ) internal pure returns (function(bytes memory) pure fnOut) {
28
        assembly {
29
            fnOut := fnIn
30
        }
31
    }
32

                            
                        
33
    function _sendLogPayload(bytes memory payload) internal pure {
34
        _castToPure(_sendLogPayloadImplementation)(payload);
35
    }
36

                            
                        
37
    function log() internal pure {
38
        _sendLogPayload(abi.encodeWithSignature("log()"));
39
    }
40

                            
                        
41
    function logInt(int256 p0) internal pure {
42
        _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
43
    }
44

                            
                        
45
    function logUint(uint256 p0) internal pure {
46
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
47
    }
48

                            
                        
49
    function logString(string memory p0) internal pure {
50
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
51
    }
52

                            
                        
53
    function logBool(bool p0) internal pure {
54
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
55
    }
56

                            
                        
57
    function logAddress(address p0) internal pure {
58
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
59
    }
60

                            
                        
61
    function logBytes(bytes memory p0) internal pure {
62
        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
63
    }
64

                            
                        
65
    function logBytes1(bytes1 p0) internal pure {
66
        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
67
    }
68

                            
                        
69
    function logBytes2(bytes2 p0) internal pure {
70
        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
71
    }
72

                            
                        
73
    function logBytes3(bytes3 p0) internal pure {
74
        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
75
    }
76

                            
                        
77
    function logBytes4(bytes4 p0) internal pure {
78
        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
79
    }
80

                            
                        
81
    function logBytes5(bytes5 p0) internal pure {
82
        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
83
    }
84

                            
                        
85
    function logBytes6(bytes6 p0) internal pure {
86
        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
87
    }
88

                            
                        
89
    function logBytes7(bytes7 p0) internal pure {
90
        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
91
    }
92

                            
                        
93
    function logBytes8(bytes8 p0) internal pure {
94
        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
95
    }
96

                            
                        
97
    function logBytes9(bytes9 p0) internal pure {
98
        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
99
    }
100

                            
                        
101
    function logBytes10(bytes10 p0) internal pure {
102
        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
103
    }
104

                            
                        
105
    function logBytes11(bytes11 p0) internal pure {
106
        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
107
    }
108

                            
                        
109
    function logBytes12(bytes12 p0) internal pure {
110
        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
111
    }
112

                            
                        
113
    function logBytes13(bytes13 p0) internal pure {
114
        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
115
    }
116

                            
                        
117
    function logBytes14(bytes14 p0) internal pure {
118
        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
119
    }
120

                            
                        
121
    function logBytes15(bytes15 p0) internal pure {
122
        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
123
    }
124

                            
                        
125
    function logBytes16(bytes16 p0) internal pure {
126
        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
127
    }
128

                            
                        
129
    function logBytes17(bytes17 p0) internal pure {
130
        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
131
    }
132

                            
                        
133
    function logBytes18(bytes18 p0) internal pure {
134
        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
135
    }
136

                            
                        
137
    function logBytes19(bytes19 p0) internal pure {
138
        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
139
    }
140

                            
                        
141
    function logBytes20(bytes20 p0) internal pure {
142
        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
143
    }
144

                            
                        
145
    function logBytes21(bytes21 p0) internal pure {
146
        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
147
    }
148

                            
                        
149
    function logBytes22(bytes22 p0) internal pure {
150
        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
151
    }
152

                            
                        
153
    function logBytes23(bytes23 p0) internal pure {
154
        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
155
    }
156

                            
                        
157
    function logBytes24(bytes24 p0) internal pure {
158
        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
159
    }
160

                            
                        
161
    function logBytes25(bytes25 p0) internal pure {
162
        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
163
    }
164

                            
                        
165
    function logBytes26(bytes26 p0) internal pure {
166
        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
167
    }
168

                            
                        
169
    function logBytes27(bytes27 p0) internal pure {
170
        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
171
    }
172

                            
                        
173
    function logBytes28(bytes28 p0) internal pure {
174
        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
175
    }
176

                            
                        
177
    function logBytes29(bytes29 p0) internal pure {
178
        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
179
    }
180

                            
                        
181
    function logBytes30(bytes30 p0) internal pure {
182
        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
183
    }
184

                            
                        
185
    function logBytes31(bytes31 p0) internal pure {
186
        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
187
    }
188

                            
                        
189
    function logBytes32(bytes32 p0) internal pure {
190
        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
191
    }
192

                            
                        
193
    function log(uint256 p0) internal pure {
194
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
195
    }
196

                            
                        
197
    function log(int256 p0) internal pure {
198
        _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
199
    }
200

                            
                        
201
    function log(string memory p0) internal pure {
202
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
203
    }
204

                            
                        
205
    function log(bool p0) internal pure {
206
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
207
    }
208

                            
                        
209
    function log(address p0) internal pure {
210
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
211
    }
212

                            
                        
213
    function log(uint256 p0, uint256 p1) internal pure {
214
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
215
    }
216

                            
                        
217
    function log(uint256 p0, string memory p1) internal pure {
218
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
219
    }
220

                            
                        
221
    function log(uint256 p0, bool p1) internal pure {
222
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
223
    }
224

                            
                        
225
    function log(uint256 p0, address p1) internal pure {
226
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
227
    }
228

                            
                        
229
    function log(string memory p0, uint256 p1) internal pure {
230
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
231
    }
232

                            
                        
233
    function log(string memory p0, int256 p1) internal pure {
234
        _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1));
235
    }
236

                            
                        
237
    function log(string memory p0, string memory p1) internal pure {
238
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
239
    }
240

                            
                        
241
    function log(string memory p0, bool p1) internal pure {
242
        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
243
    }
244

                            
                        
245
    function log(string memory p0, address p1) internal pure {
246
        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
247
    }
248

                            
                        
249
    function log(bool p0, uint256 p1) internal pure {
250
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
251
    }
252

                            
                        
253
    function log(bool p0, string memory p1) internal pure {
254
        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
255
    }
256

                            
                        
257
    function log(bool p0, bool p1) internal pure {
258
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
259
    }
260

                            
                        
261
    function log(bool p0, address p1) internal pure {
262
        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
263
    }
264

                            
                        
265
    function log(address p0, uint256 p1) internal pure {
266
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
267
    }
268

                            
                        
269
    function log(address p0, string memory p1) internal pure {
270
        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
271
    }
272

                            
                        
273
    function log(address p0, bool p1) internal pure {
274
        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
275
    }
276

                            
                        
277
    function log(address p0, address p1) internal pure {
278
        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
279
    }
280

                            
                        
281
    function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
282
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
283
    }
284

                            
                        
285
    function log(uint256 p0, uint256 p1, string memory p2) internal pure {
286
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
287
    }
288

                            
                        
289
    function log(uint256 p0, uint256 p1, bool p2) internal pure {
290
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
291
    }
292

                            
                        
293
    function log(uint256 p0, uint256 p1, address p2) internal pure {
294
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
295
    }
296

                            
                        
297
    function log(uint256 p0, string memory p1, uint256 p2) internal pure {
298
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
299
    }
300

                            
                        
301
    function log(uint256 p0, string memory p1, string memory p2) internal pure {
302
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
303
    }
304

                            
                        
305
    function log(uint256 p0, string memory p1, bool p2) internal pure {
306
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
307
    }
308

                            
                        
309
    function log(uint256 p0, string memory p1, address p2) internal pure {
310
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
311
    }
312

                            
                        
313
    function log(uint256 p0, bool p1, uint256 p2) internal pure {
314
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
315
    }
316

                            
                        
317
    function log(uint256 p0, bool p1, string memory p2) internal pure {
318
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
319
    }
320

                            
                        
321
    function log(uint256 p0, bool p1, bool p2) internal pure {
322
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
323
    }
324

                            
                        
325
    function log(uint256 p0, bool p1, address p2) internal pure {
326
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
327
    }
328

                            
                        
329
    function log(uint256 p0, address p1, uint256 p2) internal pure {
330
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
331
    }
332

                            
                        
333
    function log(uint256 p0, address p1, string memory p2) internal pure {
334
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
335
    }
336

                            
                        
337
    function log(uint256 p0, address p1, bool p2) internal pure {
338
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
339
    }
340

                            
                        
341
    function log(uint256 p0, address p1, address p2) internal pure {
342
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
343
    }
344

                            
                        
345
    function log(string memory p0, uint256 p1, uint256 p2) internal pure {
346
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
347
    }
348

                            
                        
349
    function log(string memory p0, uint256 p1, string memory p2) internal pure {
350
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
351
    }
352

                            
                        
353
    function log(string memory p0, uint256 p1, bool p2) internal pure {
354
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
355
    }
356

                            
                        
357
    function log(string memory p0, uint256 p1, address p2) internal pure {
358
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
359
    }
360

                            
                        
361
    function log(string memory p0, string memory p1, uint256 p2) internal pure {
362
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
363
    }
364

                            
                        
365
    function log(string memory p0, string memory p1, string memory p2) internal pure {
366
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
367
    }
368

                            
                        
369
    function log(string memory p0, string memory p1, bool p2) internal pure {
370
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
371
    }
372

                            
                        
373
    function log(string memory p0, string memory p1, address p2) internal pure {
374
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
375
    }
376

                            
                        
377
    function log(string memory p0, bool p1, uint256 p2) internal pure {
378
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
379
    }
380

                            
                        
381
    function log(string memory p0, bool p1, string memory p2) internal pure {
382
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
383
    }
384

                            
                        
385
    function log(string memory p0, bool p1, bool p2) internal pure {
386
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
387
    }
388

                            
                        
389
    function log(string memory p0, bool p1, address p2) internal pure {
390
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
391
    }
392

                            
                        
393
    function log(string memory p0, address p1, uint256 p2) internal pure {
394
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
395
    }
396

                            
                        
397
    function log(string memory p0, address p1, string memory p2) internal pure {
398
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
399
    }
400

                            
                        
401
    function log(string memory p0, address p1, bool p2) internal pure {
402
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
403
    }
404

                            
                        
405
    function log(string memory p0, address p1, address p2) internal pure {
406
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
407
    }
408

                            
                        
409
    function log(bool p0, uint256 p1, uint256 p2) internal pure {
410
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
411
    }
412

                            
                        
413
    function log(bool p0, uint256 p1, string memory p2) internal pure {
414
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
415
    }
416

                            
                        
417
    function log(bool p0, uint256 p1, bool p2) internal pure {
418
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
419
    }
420

                            
                        
421
    function log(bool p0, uint256 p1, address p2) internal pure {
422
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
423
    }
424

                            
                        
425
    function log(bool p0, string memory p1, uint256 p2) internal pure {
426
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
427
    }
428

                            
                        
429
    function log(bool p0, string memory p1, string memory p2) internal pure {
430
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
431
    }
432

                            
                        
433
    function log(bool p0, string memory p1, bool p2) internal pure {
434
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
435
    }
436

                            
                        
437
    function log(bool p0, string memory p1, address p2) internal pure {
438
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
439
    }
440

                            
                        
441
    function log(bool p0, bool p1, uint256 p2) internal pure {
442
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
443
    }
444

                            
                        
445
    function log(bool p0, bool p1, string memory p2) internal pure {
446
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
447
    }
448

                            
                        
449
    function log(bool p0, bool p1, bool p2) internal pure {
450
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
451
    }
452

                            
                        
453
    function log(bool p0, bool p1, address p2) internal pure {
454
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
455
    }
456

                            
                        
457
    function log(bool p0, address p1, uint256 p2) internal pure {
458
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
459
    }
460

                            
                        
461
    function log(bool p0, address p1, string memory p2) internal pure {
462
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
463
    }
464

                            
                        
465
    function log(bool p0, address p1, bool p2) internal pure {
466
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
467
    }
468

                            
                        
469
    function log(bool p0, address p1, address p2) internal pure {
470
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
471
    }
472

                            
                        
473
    function log(address p0, uint256 p1, uint256 p2) internal pure {
474
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
475
    }
476

                            
                        
477
    function log(address p0, uint256 p1, string memory p2) internal pure {
478
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
479
    }
480

                            
                        
481
    function log(address p0, uint256 p1, bool p2) internal pure {
482
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
483
    }
484

                            
                        
485
    function log(address p0, uint256 p1, address p2) internal pure {
486
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
487
    }
488

                            
                        
489
    function log(address p0, string memory p1, uint256 p2) internal pure {
490
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
491
    }
492

                            
                        
493
    function log(address p0, string memory p1, string memory p2) internal pure {
494
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
495
    }
496

                            
                        
497
    function log(address p0, string memory p1, bool p2) internal pure {
498
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
499
    }
500

                            
                        
501
    function log(address p0, string memory p1, address p2) internal pure {
502
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
503
    }
504

                            
                        
505
    function log(address p0, bool p1, uint256 p2) internal pure {
506
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
507
    }
508

                            
                        
509
    function log(address p0, bool p1, string memory p2) internal pure {
510
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
511
    }
512

                            
                        
513
    function log(address p0, bool p1, bool p2) internal pure {
514
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
515
    }
516

                            
                        
517
    function log(address p0, bool p1, address p2) internal pure {
518
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
519
    }
520

                            
                        
521
    function log(address p0, address p1, uint256 p2) internal pure {
522
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
523
    }
524

                            
                        
525
    function log(address p0, address p1, string memory p2) internal pure {
526
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
527
    }
528

                            
                        
529
    function log(address p0, address p1, bool p2) internal pure {
530
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
531
    }
532

                            
                        
533
    function log(address p0, address p1, address p2) internal pure {
534
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
535
    }
536

                            
                        
537
    function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
538
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
539
    }
540

                            
                        
541
    function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
542
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
543
    }
544

                            
                        
545
    function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
546
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
547
    }
548

                            
                        
549
    function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
550
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
551
    }
552

                            
                        
553
    function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
554
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
555
    }
556

                            
                        
557
    function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
558
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
559
    }
560

                            
                        
561
    function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
562
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
563
    }
564

                            
                        
565
    function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
566
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
567
    }
568

                            
                        
569
    function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
570
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
571
    }
572

                            
                        
573
    function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
574
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
575
    }
576

                            
                        
577
    function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
578
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
579
    }
580

                            
                        
581
    function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
582
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
583
    }
584

                            
                        
585
    function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
586
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
587
    }
588

                            
                        
589
    function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
590
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
591
    }
592

                            
                        
593
    function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
594
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
595
    }
596

                            
                        
597
    function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
598
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
599
    }
600

                            
                        
601
    function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
602
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
603
    }
604

                            
                        
605
    function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
606
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
607
    }
608

                            
                        
609
    function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
610
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
611
    }
612

                            
                        
613
    function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
614
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
615
    }
616

                            
                        
617
    function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
618
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
619
    }
620

                            
                        
621
    function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
622
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
623
    }
624

                            
                        
625
    function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
626
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
627
    }
628

                            
                        
629
    function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
630
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
631
    }
632

                            
                        
633
    function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
634
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
635
    }
636

                            
                        
637
    function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
638
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
639
    }
640

                            
                        
641
    function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
642
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
643
    }
644

                            
                        
645
    function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
646
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
647
    }
648

                            
                        
649
    function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
650
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
651
    }
652

                            
                        
653
    function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
654
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
655
    }
656

                            
                        
657
    function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
658
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
659
    }
660

                            
                        
661
    function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
662
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
663
    }
664

                            
                        
665
    function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
666
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
667
    }
668

                            
                        
669
    function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
670
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
671
    }
672

                            
                        
673
    function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
674
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
675
    }
676

                            
                        
677
    function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
678
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
679
    }
680

                            
                        
681
    function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
682
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
683
    }
684

                            
                        
685
    function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
686
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
687
    }
688

                            
                        
689
    function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
690
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
691
    }
692

                            
                        
693
    function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
694
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
695
    }
696

                            
                        
697
    function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
698
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
699
    }
700

                            
                        
701
    function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
702
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
703
    }
704

                            
                        
705
    function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
706
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
707
    }
708

                            
                        
709
    function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
710
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
711
    }
712

                            
                        
713
    function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
714
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
715
    }
716

                            
                        
717
    function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
718
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
719
    }
720

                            
                        
721
    function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
722
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
723
    }
724

                            
                        
725
    function log(uint256 p0, bool p1, address p2, address p3) internal pure {
726
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
727
    }
728

                            
                        
729
    function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
730
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
731
    }
732

                            
                        
733
    function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
734
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
735
    }
736

                            
                        
737
    function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
738
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
739
    }
740

                            
                        
741
    function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
742
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
743
    }
744

                            
                        
745
    function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
746
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
747
    }
748

                            
                        
749
    function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
750
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
751
    }
752

                            
                        
753
    function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
754
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
755
    }
756

                            
                        
757
    function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
758
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
759
    }
760

                            
                        
761
    function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
762
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
763
    }
764

                            
                        
765
    function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
766
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
767
    }
768

                            
                        
769
    function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
770
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
771
    }
772

                            
                        
773
    function log(uint256 p0, address p1, bool p2, address p3) internal pure {
774
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
775
    }
776

                            
                        
777
    function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
778
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
779
    }
780

                            
                        
781
    function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
782
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
783
    }
784

                            
                        
785
    function log(uint256 p0, address p1, address p2, bool p3) internal pure {
786
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
787
    }
788

                            
                        
789
    function log(uint256 p0, address p1, address p2, address p3) internal pure {
790
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
791
    }
792

                            
                        
793
    function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
794
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
795
    }
796

                            
                        
797
    function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
798
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
799
    }
800

                            
                        
801
    function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
802
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
803
    }
804

                            
                        
805
    function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
806
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
807
    }
808

                            
                        
809
    function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
810
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
811
    }
812

                            
                        
813
    function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
814
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
815
    }
816

                            
                        
817
    function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
818
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
819
    }
820

                            
                        
821
    function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
822
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
823
    }
824

                            
                        
825
    function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
826
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
827
    }
828

                            
                        
829
    function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
830
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
831
    }
832

                            
                        
833
    function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
834
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
835
    }
836

                            
                        
837
    function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
838
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
839
    }
840

                            
                        
841
    function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
842
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
843
    }
844

                            
                        
845
    function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
846
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
847
    }
848

                            
                        
849
    function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
850
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
851
    }
852

                            
                        
853
    function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
854
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
855
    }
856

                            
                        
857
    function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
858
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
859
    }
860

                            
                        
861
    function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
862
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
863
    }
864

                            
                        
865
    function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
866
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
867
    }
868

                            
                        
869
    function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
870
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
871
    }
872

                            
                        
873
    function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
874
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
875
    }
876

                            
                        
877
    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
878
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
879
    }
880

                            
                        
881
    function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
882
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
883
    }
884

                            
                        
885
    function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
886
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
887
    }
888

                            
                        
889
    function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
890
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
891
    }
892

                            
                        
893
    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
894
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
895
    }
896

                            
                        
897
    function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
898
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
899
    }
900

                            
                        
901
    function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
902
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
903
    }
904

                            
                        
905
    function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
906
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
907
    }
908

                            
                        
909
    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
910
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
911
    }
912

                            
                        
913
    function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
914
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
915
    }
916

                            
                        
917
    function log(string memory p0, string memory p1, address p2, address p3) internal pure {
918
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
919
    }
920

                            
                        
921
    function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
922
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
923
    }
924

                            
                        
925
    function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
926
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
927
    }
928

                            
                        
929
    function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
930
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
931
    }
932

                            
                        
933
    function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
934
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
935
    }
936

                            
                        
937
    function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
938
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
939
    }
940

                            
                        
941
    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
942
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
943
    }
944

                            
                        
945
    function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
946
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
947
    }
948

                            
                        
949
    function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
950
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
951
    }
952

                            
                        
953
    function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
954
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
955
    }
956

                            
                        
957
    function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
958
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
959
    }
960

                            
                        
961
    function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
962
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
963
    }
964

                            
                        
965
    function log(string memory p0, bool p1, bool p2, address p3) internal pure {
966
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
967
    }
968

                            
                        
969
    function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
970
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
971
    }
972

                            
                        
973
    function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
974
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
975
    }
976

                            
                        
977
    function log(string memory p0, bool p1, address p2, bool p3) internal pure {
978
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
979
    }
980

                            
                        
981
    function log(string memory p0, bool p1, address p2, address p3) internal pure {
982
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
983
    }
984

                            
                        
985
    function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
986
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
987
    }
988

                            
                        
989
    function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
990
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
991
    }
992

                            
                        
993
    function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
994
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
995
    }
996

                            
                        
997
    function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
998
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
999
    }
1000

                            
                        
1001
    function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
1002
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
1003
    }
1004

                            
                        
1005
    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
1006
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
1007
    }
1008

                            
                        
1009
    function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
1010
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
1011
    }
1012

                            
                        
1013
    function log(string memory p0, address p1, string memory p2, address p3) internal pure {
1014
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
1015
    }
1016

                            
                        
1017
    function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
1018
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
1019
    }
1020

                            
                        
1021
    function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
1022
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
1023
    }
1024

                            
                        
1025
    function log(string memory p0, address p1, bool p2, bool p3) internal pure {
1026
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
1027
    }
1028

                            
                        
1029
    function log(string memory p0, address p1, bool p2, address p3) internal pure {
1030
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
1031
    }
1032

                            
                        
1033
    function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
1034
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
1035
    }
1036

                            
                        
1037
    function log(string memory p0, address p1, address p2, string memory p3) internal pure {
1038
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
1039
    }
1040

                            
                        
1041
    function log(string memory p0, address p1, address p2, bool p3) internal pure {
1042
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
1043
    }
1044

                            
                        
1045
    function log(string memory p0, address p1, address p2, address p3) internal pure {
1046
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
1047
    }
1048

                            
                        
1049
    function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
1050
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
1051
    }
1052

                            
                        
1053
    function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
1054
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
1055
    }
1056

                            
                        
1057
    function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
1058
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
1059
    }
1060

                            
                        
1061
    function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
1062
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
1063
    }
1064

                            
                        
1065
    function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
1066
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
1067
    }
1068

                            
                        
1069
    function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
1070
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
1071
    }
1072

                            
                        
1073
    function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
1074
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
1075
    }
1076

                            
                        
1077
    function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
1078
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
1079
    }
1080

                            
                        
1081
    function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
1082
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
1083
    }
1084

                            
                        
1085
    function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
1086
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
1087
    }
1088

                            
                        
1089
    function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
1090
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
1091
    }
1092

                            
                        
1093
    function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
1094
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
1095
    }
1096

                            
                        
1097
    function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
1098
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
1099
    }
1100

                            
                        
1101
    function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
1102
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
1103
    }
1104

                            
                        
1105
    function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
1106
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
1107
    }
1108

                            
                        
1109
    function log(bool p0, uint256 p1, address p2, address p3) internal pure {
1110
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
1111
    }
1112

                            
                        
1113
    function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
1114
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
1115
    }
1116

                            
                        
1117
    function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
1118
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
1119
    }
1120

                            
                        
1121
    function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
1122
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
1123
    }
1124

                            
                        
1125
    function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
1126
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
1127
    }
1128

                            
                        
1129
    function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
1130
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
1131
    }
1132

                            
                        
1133
    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
1134
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
1135
    }
1136

                            
                        
1137
    function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
1138
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
1139
    }
1140

                            
                        
1141
    function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
1142
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
1143
    }
1144

                            
                        
1145
    function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
1146
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
1147
    }
1148

                            
                        
1149
    function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
1150
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
1151
    }
1152

                            
                        
1153
    function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
1154
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
1155
    }
1156

                            
                        
1157
    function log(bool p0, string memory p1, bool p2, address p3) internal pure {
1158
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
1159
    }
1160

                            
                        
1161
    function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
1162
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
1163
    }
1164

                            
                        
1165
    function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
1166
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
1167
    }
1168

                            
                        
1169
    function log(bool p0, string memory p1, address p2, bool p3) internal pure {
1170
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
1171
    }
1172

                            
                        
1173
    function log(bool p0, string memory p1, address p2, address p3) internal pure {
1174
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
1175
    }
1176

                            
                        
1177
    function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
1178
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
1179
    }
1180

                            
                        
1181
    function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
1182
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
1183
    }
1184

                            
                        
1185
    function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
1186
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
1187
    }
1188

                            
                        
1189
    function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
1190
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
1191
    }
1192

                            
                        
1193
    function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
1194
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
1195
    }
1196

                            
                        
1197
    function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
1198
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
1199
    }
1200

                            
                        
1201
    function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
1202
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
1203
    }
1204

                            
                        
1205
    function log(bool p0, bool p1, string memory p2, address p3) internal pure {
1206
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
1207
    }
1208

                            
                        
1209
    function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
1210
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
1211
    }
1212

                            
                        
1213
    function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
1214
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
1215
    }
1216

                            
                        
1217
    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
1218
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
1219
    }
1220

                            
                        
1221
    function log(bool p0, bool p1, bool p2, address p3) internal pure {
1222
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
1223
    }
1224

                            
                        
1225
    function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
1226
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
1227
    }
1228

                            
                        
1229
    function log(bool p0, bool p1, address p2, string memory p3) internal pure {
1230
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
1231
    }
1232

                            
                        
1233
    function log(bool p0, bool p1, address p2, bool p3) internal pure {
1234
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
1235
    }
1236

                            
                        
1237
    function log(bool p0, bool p1, address p2, address p3) internal pure {
1238
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
1239
    }
1240

                            
                        
1241
    function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
1242
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
1243
    }
1244

                            
                        
1245
    function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
1246
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
1247
    }
1248

                            
                        
1249
    function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
1250
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
1251
    }
1252

                            
                        
1253
    function log(bool p0, address p1, uint256 p2, address p3) internal pure {
1254
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
1255
    }
1256

                            
                        
1257
    function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
1258
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
1259
    }
1260

                            
                        
1261
    function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
1262
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
1263
    }
1264

                            
                        
1265
    function log(bool p0, address p1, string memory p2, bool p3) internal pure {
1266
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
1267
    }
1268

                            
                        
1269
    function log(bool p0, address p1, string memory p2, address p3) internal pure {
1270
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
1271
    }
1272

                            
                        
1273
    function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
1274
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
1275
    }
1276

                            
                        
1277
    function log(bool p0, address p1, bool p2, string memory p3) internal pure {
1278
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
1279
    }
1280

                            
                        
1281
    function log(bool p0, address p1, bool p2, bool p3) internal pure {
1282
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
1283
    }
1284

                            
                        
1285
    function log(bool p0, address p1, bool p2, address p3) internal pure {
1286
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
1287
    }
1288

                            
                        
1289
    function log(bool p0, address p1, address p2, uint256 p3) internal pure {
1290
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
1291
    }
1292

                            
                        
1293
    function log(bool p0, address p1, address p2, string memory p3) internal pure {
1294
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
1295
    }
1296

                            
                        
1297
    function log(bool p0, address p1, address p2, bool p3) internal pure {
1298
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
1299
    }
1300

                            
                        
1301
    function log(bool p0, address p1, address p2, address p3) internal pure {
1302
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
1303
    }
1304

                            
                        
1305
    function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
1306
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
1307
    }
1308

                            
                        
1309
    function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
1310
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
1311
    }
1312

                            
                        
1313
    function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
1314
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
1315
    }
1316

                            
                        
1317
    function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
1318
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
1319
    }
1320

                            
                        
1321
    function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
1322
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
1323
    }
1324

                            
                        
1325
    function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
1326
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
1327
    }
1328

                            
                        
1329
    function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
1330
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
1331
    }
1332

                            
                        
1333
    function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
1334
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
1335
    }
1336

                            
                        
1337
    function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
1338
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
1339
    }
1340

                            
                        
1341
    function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
1342
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
1343
    }
1344

                            
                        
1345
    function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
1346
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
1347
    }
1348

                            
                        
1349
    function log(address p0, uint256 p1, bool p2, address p3) internal pure {
1350
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
1351
    }
1352

                            
                        
1353
    function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
1354
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
1355
    }
1356

                            
                        
1357
    function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
1358
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
1359
    }
1360

                            
                        
1361
    function log(address p0, uint256 p1, address p2, bool p3) internal pure {
1362
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
1363
    }
1364

                            
                        
1365
    function log(address p0, uint256 p1, address p2, address p3) internal pure {
1366
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
1367
    }
1368

                            
                        
1369
    function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
1370
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
1371
    }
1372

                            
                        
1373
    function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
1374
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
1375
    }
1376

                            
                        
1377
    function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
1378
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
1379
    }
1380

                            
                        
1381
    function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
1382
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
1383
    }
1384

                            
                        
1385
    function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
1386
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
1387
    }
1388

                            
                        
1389
    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
1390
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
1391
    }
1392

                            
                        
1393
    function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
1394
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
1395
    }
1396

                            
                        
1397
    function log(address p0, string memory p1, string memory p2, address p3) internal pure {
1398
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
1399
    }
1400

                            
                        
1401
    function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
1402
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
1403
    }
1404

                            
                        
1405
    function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
1406
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
1407
    }
1408

                            
                        
1409
    function log(address p0, string memory p1, bool p2, bool p3) internal pure {
1410
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
1411
    }
1412

                            
                        
1413
    function log(address p0, string memory p1, bool p2, address p3) internal pure {
1414
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
1415
    }
1416

                            
                        
1417
    function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
1418
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
1419
    }
1420

                            
                        
1421
    function log(address p0, string memory p1, address p2, string memory p3) internal pure {
1422
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
1423
    }
1424

                            
                        
1425
    function log(address p0, string memory p1, address p2, bool p3) internal pure {
1426
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
1427
    }
1428

                            
                        
1429
    function log(address p0, string memory p1, address p2, address p3) internal pure {
1430
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
1431
    }
1432

                            
                        
1433
    function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
1434
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
1435
    }
1436

                            
                        
1437
    function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
1438
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
1439
    }
1440

                            
                        
1441
    function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
1442
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
1443
    }
1444

                            
                        
1445
    function log(address p0, bool p1, uint256 p2, address p3) internal pure {
1446
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
1447
    }
1448

                            
                        
1449
    function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
1450
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
1451
    }
1452

                            
                        
1453
    function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
1454
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
1455
    }
1456

                            
                        
1457
    function log(address p0, bool p1, string memory p2, bool p3) internal pure {
1458
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
1459
    }
1460

                            
                        
1461
    function log(address p0, bool p1, string memory p2, address p3) internal pure {
1462
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
1463
    }
1464

                            
                        
1465
    function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
1466
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
1467
    }
1468

                            
                        
1469
    function log(address p0, bool p1, bool p2, string memory p3) internal pure {
1470
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
1471
    }
1472

                            
                        
1473
    function log(address p0, bool p1, bool p2, bool p3) internal pure {
1474
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
1475
    }
1476

                            
                        
1477
    function log(address p0, bool p1, bool p2, address p3) internal pure {
1478
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
1479
    }
1480

                            
                        
1481
    function log(address p0, bool p1, address p2, uint256 p3) internal pure {
1482
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
1483
    }
1484

                            
                        
1485
    function log(address p0, bool p1, address p2, string memory p3) internal pure {
1486
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
1487
    }
1488

                            
                        
1489
    function log(address p0, bool p1, address p2, bool p3) internal pure {
1490
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
1491
    }
1492

                            
                        
1493
    function log(address p0, bool p1, address p2, address p3) internal pure {
1494
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
1495
    }
1496

                            
                        
1497
    function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
1498
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
1499
    }
1500

                            
                        
1501
    function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
1502
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
1503
    }
1504

                            
                        
1505
    function log(address p0, address p1, uint256 p2, bool p3) internal pure {
1506
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
1507
    }
1508

                            
                        
1509
    function log(address p0, address p1, uint256 p2, address p3) internal pure {
1510
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
1511
    }
1512

                            
                        
1513
    function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
1514
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
1515
    }
1516

                            
                        
1517
    function log(address p0, address p1, string memory p2, string memory p3) internal pure {
1518
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
1519
    }
1520

                            
                        
1521
    function log(address p0, address p1, string memory p2, bool p3) internal pure {
1522
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
1523
    }
1524

                            
                        
1525
    function log(address p0, address p1, string memory p2, address p3) internal pure {
1526
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
1527
    }
1528

                            
                        
1529
    function log(address p0, address p1, bool p2, uint256 p3) internal pure {
1530
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
1531
    }
1532

                            
                        
1533
    function log(address p0, address p1, bool p2, string memory p3) internal pure {
1534
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
1535
    }
1536

                            
                        
1537
    function log(address p0, address p1, bool p2, bool p3) internal pure {
1538
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
1539
    }
1540

                            
                        
1541
    function log(address p0, address p1, bool p2, address p3) internal pure {
1542
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
1543
    }
1544

                            
                        
1545
    function log(address p0, address p1, address p2, uint256 p3) internal pure {
1546
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
1547
    }
1548

                            
                        
1549
    function log(address p0, address p1, address p2, string memory p3) internal pure {
1550
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
1551
    }
1552

                            
                        
1553
    function log(address p0, address p1, address p2, bool p3) internal pure {
1554
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
1555
    }
1556

                            
                        
1557
    function log(address p0, address p1, address p2, address p3) internal pure {
1558
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
1559
    }
1560
}
1561

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.4.22 <0.9.0;
3

                            
                        
4
import {console as console2} from "./console.sol";
5

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2;
3

                            
                        
4
interface IERC165 {
5
    /// @notice Query if a contract implements an interface
6
    /// @param interfaceID The interface identifier, as specified in ERC-165
7
    /// @dev Interface identification is specified in ERC-165. This function
8
    /// uses less than 30,000 gas.
9
    /// @return `true` if the contract implements `interfaceID` and
10
    /// `interfaceID` is not 0xffffffff, `false` otherwise
11
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
12
}
13

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2;
3

                            
                        
4
/// @dev Interface of the ERC20 standard as defined in the EIP.
5
/// @dev This includes the optional name, symbol, and decimals metadata.
6
interface IERC20 {
7
    /// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
8
    event Transfer(address indexed from, address indexed to, uint256 value);
9

                            
                        
10
    /// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value`
11
    /// is the new allowance.
12
    event Approval(address indexed owner, address indexed spender, uint256 value);
13

                            
                        
14
    /// @notice Returns the amount of tokens in existence.
15
    function totalSupply() external view returns (uint256);
16

                            
                        
17
    /// @notice Returns the amount of tokens owned by `account`.
18
    function balanceOf(address account) external view returns (uint256);
19

                            
                        
20
    /// @notice Moves `amount` tokens from the caller's account to `to`.
21
    function transfer(address to, uint256 amount) external returns (bool);
22

                            
                        
23
    /// @notice Returns the remaining number of tokens that `spender` is allowed
24
    /// to spend on behalf of `owner`
25
    function allowance(address owner, address spender) external view returns (uint256);
26

                            
                        
27
    /// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
28
    /// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
29
    function approve(address spender, uint256 amount) external returns (bool);
30

                            
                        
31
    /// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism.
32
    /// `amount` is then deducted from the caller's allowance.
33
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
34

                            
                        
35
    /// @notice Returns the name of the token.
36
    function name() external view returns (string memory);
37

                            
                        
38
    /// @notice Returns the symbol of the token.
39
    function symbol() external view returns (string memory);
40

                            
                        
41
    /// @notice Returns the decimals places of the token.
42
    function decimals() external view returns (uint8);
43
}
44

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2;
3

                            
                        
4
import "./IERC165.sol";
5

                            
                        
6
/// @title ERC-721 Non-Fungible Token Standard
7
/// @dev See https://eips.ethereum.org/EIPS/eip-721
8
/// Note: the ERC-165 identifier for this interface is 0x80ac58cd.
9
interface IERC721 is IERC165 {
10
    /// @dev This emits when ownership of any NFT changes by any mechanism.
11
    /// This event emits when NFTs are created (`from` == 0) and destroyed
12
    /// (`to` == 0). Exception: during contract creation, any number of NFTs
13
    /// may be created and assigned without emitting Transfer. At the time of
14
    /// any transfer, the approved address for that NFT (if any) is reset to none.
15
    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
16

                            
                        
17
    /// @dev This emits when the approved address for an NFT is changed or
18
    /// reaffirmed. The zero address indicates there is no approved address.
19
    /// When a Transfer event emits, this also indicates that the approved
20
    /// address for that NFT (if any) is reset to none.
21
    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
22

                            
                        
23
    /// @dev This emits when an operator is enabled or disabled for an owner.
24
    /// The operator can manage all NFTs of the owner.
25
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
26

                            
                        
27
    /// @notice Count all NFTs assigned to an owner
28
    /// @dev NFTs assigned to the zero address are considered invalid, and this
29
    /// function throws for queries about the zero address.
30
    /// @param _owner An address for whom to query the balance
31
    /// @return The number of NFTs owned by `_owner`, possibly zero
32
    function balanceOf(address _owner) external view returns (uint256);
33

                            
                        
34
    /// @notice Find the owner of an NFT
35
    /// @dev NFTs assigned to zero address are considered invalid, and queries
36
    /// about them do throw.
37
    /// @param _tokenId The identifier for an NFT
38
    /// @return The address of the owner of the NFT
39
    function ownerOf(uint256 _tokenId) external view returns (address);
40

                            
                        
41
    /// @notice Transfers the ownership of an NFT from one address to another address
42
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
43
    /// operator, or the approved address for this NFT. Throws if `_from` is
44
    /// not the current owner. Throws if `_to` is the zero address. Throws if
45
    /// `_tokenId` is not a valid NFT. When transfer is complete, this function
46
    /// checks if `_to` is a smart contract (code size > 0). If so, it calls
47
    /// `onERC721Received` on `_to` and throws if the return value is not
48
    /// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
49
    /// @param _from The current owner of the NFT
50
    /// @param _to The new owner
51
    /// @param _tokenId The NFT to transfer
52
    /// @param data Additional data with no specified format, sent in call to `_to`
53
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external payable;
54

                            
                        
55
    /// @notice Transfers the ownership of an NFT from one address to another address
56
    /// @dev This works identically to the other function with an extra data parameter,
57
    /// except this function just sets data to "".
58
    /// @param _from The current owner of the NFT
59
    /// @param _to The new owner
60
    /// @param _tokenId The NFT to transfer
61
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
62

                            
                        
63
    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
64
    /// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
65
    /// THEY MAY BE PERMANENTLY LOST
66
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
67
    /// operator, or the approved address for this NFT. Throws if `_from` is
68
    /// not the current owner. Throws if `_to` is the zero address. Throws if
69
    /// `_tokenId` is not a valid NFT.
70
    /// @param _from The current owner of the NFT
71
    /// @param _to The new owner
72
    /// @param _tokenId The NFT to transfer
73
    function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
74

                            
                        
75
    /// @notice Change or reaffirm the approved address for an NFT
76
    /// @dev The zero address indicates there is no approved address.
77
    /// Throws unless `msg.sender` is the current NFT owner, or an authorized
78
    /// operator of the current owner.
79
    /// @param _approved The new approved NFT controller
80
    /// @param _tokenId The NFT to approve
81
    function approve(address _approved, uint256 _tokenId) external payable;
82

                            
                        
83
    /// @notice Enable or disable approval for a third party ("operator") to manage
84
    /// all of `msg.sender`'s assets
85
    /// @dev Emits the ApprovalForAll event. The contract MUST allow
86
    /// multiple operators per owner.
87
    /// @param _operator Address to add to the set of authorized operators
88
    /// @param _approved True if the operator is approved, false to revoke approval
89
    function setApprovalForAll(address _operator, bool _approved) external;
90

                            
                        
91
    /// @notice Get the approved address for a single NFT
92
    /// @dev Throws if `_tokenId` is not a valid NFT.
93
    /// @param _tokenId The NFT to find the approved address for
94
    /// @return The approved address for this NFT, or the zero address if there is none
95
    function getApproved(uint256 _tokenId) external view returns (address);
96

                            
                        
97
    /// @notice Query if an address is an authorized operator for another address
98
    /// @param _owner The address that owns the NFTs
99
    /// @param _operator The address that acts on behalf of the owner
100
    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
101
    function isApprovedForAll(address _owner, address _operator) external view returns (bool);
102
}
103

                            
                        
104
/// @dev Note: the ERC-165 identifier for this interface is 0x150b7a02.
105
interface IERC721TokenReceiver {
106
    /// @notice Handle the receipt of an NFT
107
    /// @dev The ERC721 smart contract calls this function on the recipient
108
    /// after a `transfer`. This function MAY throw to revert and reject the
109
    /// transfer. Return of other than the magic value MUST result in the
110
    /// transaction being reverted.
111
    /// Note: the contract address is always the message sender.
112
    /// @param _operator The address which called `safeTransferFrom` function
113
    /// @param _from The address which previously owned the token
114
    /// @param _tokenId The NFT identifier which is being transferred
115
    /// @param _data Additional data with no specified format
116
    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
117
    ///  unless throwing
118
    function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data)
119
        external
120
        returns (bytes4);
121
}
122

                            
                        
123
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
124
/// @dev See https://eips.ethereum.org/EIPS/eip-721
125
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f.
126
interface IERC721Metadata is IERC721 {
127
    /// @notice A descriptive name for a collection of NFTs in this contract
128
    function name() external view returns (string memory _name);
129

                            
                        
130
    /// @notice An abbreviated name for NFTs in this contract
131
    function symbol() external view returns (string memory _symbol);
132

                            
                        
133
    /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
134
    /// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
135
    /// 3986. The URI may point to a JSON file that conforms to the "ERC721
136
    /// Metadata JSON Schema".
137
    function tokenURI(uint256 _tokenId) external view returns (string memory);
138
}
139

                            
                        
140
/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
141
/// @dev See https://eips.ethereum.org/EIPS/eip-721
142
/// Note: the ERC-165 identifier for this interface is 0x780e9d63.
143
interface IERC721Enumerable is IERC721 {
144
    /// @notice Count NFTs tracked by this contract
145
    /// @return A count of valid NFTs tracked by this contract, where each one of
146
    /// them has an assigned and queryable owner not equal to the zero address
147
    function totalSupply() external view returns (uint256);
148

                            
                        
149
    /// @notice Enumerate valid NFTs
150
    /// @dev Throws if `_index` >= `totalSupply()`.
151
    /// @param _index A counter less than `totalSupply()`
152
    /// @return The token identifier for the `_index`th NFT,
153
    /// (sort order not specified)
154
    function tokenByIndex(uint256 _index) external view returns (uint256);
155

                            
                        
156
    /// @notice Enumerate NFTs assigned to an owner
157
    /// @dev Throws if `_index` >= `balanceOf(_owner)` or if
158
    /// `_owner` is the zero address, representing invalid NFTs.
159
    /// @param _owner An address where we are interested in NFTs owned by them
160
    /// @param _index A counter less than `balanceOf(_owner)`
161
    /// @return The token identifier for the `_index`th NFT assigned to `_owner`,
162
    /// (sort order not specified)
163
    function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
164
}
165

                            
                        

Lines covered: 0 / 0 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
pragma experimental ABIEncoderV2;
5

                            
                        
6
interface IMulticall3 {
7
    struct Call {
8
        address target;
9
        bytes callData;
10
    }
11

                            
                        
12
    struct Call3 {
13
        address target;
14
        bool allowFailure;
15
        bytes callData;
16
    }
17

                            
                        
18
    struct Call3Value {
19
        address target;
20
        bool allowFailure;
21
        uint256 value;
22
        bytes callData;
23
    }
24

                            
                        
25
    struct Result {
26
        bool success;
27
        bytes returnData;
28
    }
29

                            
                        
30
    function aggregate(Call[] calldata calls)
31
        external
32
        payable
33
        returns (uint256 blockNumber, bytes[] memory returnData);
34

                            
                        
35
    function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
36

                            
                        
37
    function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
38

                            
                        
39
    function blockAndAggregate(Call[] calldata calls)
40
        external
41
        payable
42
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
43

                            
                        
44
    function getBasefee() external view returns (uint256 basefee);
45

                            
                        
46
    function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
47

                            
                        
48
    function getBlockNumber() external view returns (uint256 blockNumber);
49

                            
                        
50
    function getChainId() external view returns (uint256 chainid);
51

                            
                        
52
    function getCurrentBlockCoinbase() external view returns (address coinbase);
53

                            
                        
54
    function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
55

                            
                        
56
    function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
57

                            
                        
58
    function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
59

                            
                        
60
    function getEthBalance(address addr) external view returns (uint256 balance);
61

                            
                        
62
    function getLastBlockHash() external view returns (bytes32 blockHash);
63

                            
                        
64
    function tryAggregate(bool requireSuccess, Call[] calldata calls)
65
        external
66
        payable
67
        returns (Result[] memory returnData);
68

                            
                        
69
    function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
70
        external
71
        payable
72
        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
73
}
74

                            
                        

Lines covered: 0 / 63 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
import {IERC20} from "../interfaces/IERC20.sol";
5

                            
                        
6
/// @notice This is a mock contract of the ERC20 standard for testing purposes only, it SHOULD NOT be used in production.
7
/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC20.sol
8
contract MockERC20 is IERC20 {
9
    /*//////////////////////////////////////////////////////////////
10
                            METADATA STORAGE
11
    //////////////////////////////////////////////////////////////*/
12

                            
                        
13
    string internal _name;
14

                            
                        
15
    string internal _symbol;
16

                            
                        
17
    uint8 internal _decimals;
18

                            
                        
19
    function name() external view override returns (string memory) {
20
        return _name;
21
    }
22

                            
                        
23
    function symbol() external view override returns (string memory) {
24
        return _symbol;
25
    }
26

                            
                        
27
    function decimals() external view override returns (uint8) {
28
        return _decimals;
29
    }
30

                            
                        
31
    /*//////////////////////////////////////////////////////////////
32
                              ERC20 STORAGE
33
    //////////////////////////////////////////////////////////////*/
34

                            
                        
35
    uint256 internal _totalSupply;
36

                            
                        
37
    mapping(address => uint256) internal _balanceOf;
38

                            
                        
39
    mapping(address => mapping(address => uint256)) internal _allowance;
40

                            
                        
41
    function totalSupply() external view override returns (uint256) {
42
        return _totalSupply;
43
    }
44

                            
                        
45
    function balanceOf(address owner) external view override returns (uint256) {
46
        return _balanceOf[owner];
47
    }
48

                            
                        
49
    function allowance(address owner, address spender) external view override returns (uint256) {
50
        return _allowance[owner][spender];
51
    }
52

                            
                        
53
    /*//////////////////////////////////////////////////////////////
54
                            EIP-2612 STORAGE
55
    //////////////////////////////////////////////////////////////*/
56

                            
                        
57
    uint256 internal INITIAL_CHAIN_ID;
58

                            
                        
59
    bytes32 internal INITIAL_DOMAIN_SEPARATOR;
60

                            
                        
61
    mapping(address => uint256) public nonces;
62

                            
                        
63
    /*//////////////////////////////////////////////////////////////
64
                               INITIALIZE
65
    //////////////////////////////////////////////////////////////*/
66

                            
                        
67
    /// @dev A bool to track whether the contract has been initialized.
68
    bool private initialized;
69

                            
                        
70
    /// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and
71
    /// syntaxes, we add an initialization function that can be called only once.
72
    function initialize(string memory name_, string memory symbol_, uint8 decimals_) public {
73
        require(!initialized, "ALREADY_INITIALIZED");
74

                            
                        
75
        _name = name_;
76
        _symbol = symbol_;
77
        _decimals = decimals_;
78

                            
                        
79
        INITIAL_CHAIN_ID = _pureChainId();
80
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
81

                            
                        
82
        initialized = true;
83
    }
84

                            
                        
85
    /*//////////////////////////////////////////////////////////////
86
                               ERC20 LOGIC
87
    //////////////////////////////////////////////////////////////*/
88

                            
                        
89
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
90
        _allowance[msg.sender][spender] = amount;
91

                            
                        
92
        emit Approval(msg.sender, spender, amount);
93

                            
                        
94
        return true;
95
    }
96

                            
                        
97
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
98
        _balanceOf[msg.sender] = _sub(_balanceOf[msg.sender], amount);
99
        _balanceOf[to] = _add(_balanceOf[to], amount);
100

                            
                        
101
        emit Transfer(msg.sender, to, amount);
102

                            
                        
103
        return true;
104
    }
105

                            
                        
106
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
107
        uint256 allowed = _allowance[from][msg.sender]; // Saves gas for limited approvals.
108

                            
                        
109
        if (allowed != ~uint256(0)) _allowance[from][msg.sender] = _sub(allowed, amount);
110

                            
                        
111
        _balanceOf[from] = _sub(_balanceOf[from], amount);
112
        _balanceOf[to] = _add(_balanceOf[to], amount);
113

                            
                        
114
        emit Transfer(from, to, amount);
115

                            
                        
116
        return true;
117
    }
118

                            
                        
119
    /*//////////////////////////////////////////////////////////////
120
                             EIP-2612 LOGIC
121
    //////////////////////////////////////////////////////////////*/
122

                            
                        
123
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
124
        public
125
        virtual
126
    {
127
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
128

                            
                        
129
        address recoveredAddress = ecrecover(
130
            keccak256(
131
                abi.encodePacked(
132
                    "\x19\x01",
133
                    DOMAIN_SEPARATOR(),
134
                    keccak256(
135
                        abi.encode(
136
                            keccak256(
137
                                "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
138
                            ),
139
                            owner,
140
                            spender,
141
                            value,
142
                            nonces[owner]++,
143
                            deadline
144
                        )
145
                    )
146
                )
147
            ),
148
            v,
149
            r,
150
            s
151
        );
152

                            
                        
153
        require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
154

                            
                        
155
        _allowance[recoveredAddress][spender] = value;
156

                            
                        
157
        emit Approval(owner, spender, value);
158
    }
159

                            
                        
160
    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
161
        return _pureChainId() == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
162
    }
163

                            
                        
164
    function computeDomainSeparator() internal view virtual returns (bytes32) {
165
        return keccak256(
166
            abi.encode(
167
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
168
                keccak256(bytes(_name)),
169
                keccak256("1"),
170
                _pureChainId(),
171
                address(this)
172
            )
173
        );
174
    }
175

                            
                        
176
    /*//////////////////////////////////////////////////////////////
177
                        INTERNAL MINT/BURN LOGIC
178
    //////////////////////////////////////////////////////////////*/
179

                            
                        
180
    function _mint(address to, uint256 amount) internal virtual {
181
        _totalSupply = _add(_totalSupply, amount);
182
        _balanceOf[to] = _add(_balanceOf[to], amount);
183

                            
                        
184
        emit Transfer(address(0), to, amount);
185
    }
186

                            
                        
187
    function _burn(address from, uint256 amount) internal virtual {
188
        _balanceOf[from] = _sub(_balanceOf[from], amount);
189
        _totalSupply = _sub(_totalSupply, amount);
190

                            
                        
191
        emit Transfer(from, address(0), amount);
192
    }
193

                            
                        
194
    /*//////////////////////////////////////////////////////////////
195
                        INTERNAL SAFE MATH LOGIC
196
    //////////////////////////////////////////////////////////////*/
197

                            
                        
198
    function _add(uint256 a, uint256 b) internal pure returns (uint256) {
199
        uint256 c = a + b;
200
        require(c >= a, "ERC20: addition overflow");
201
        return c;
202
    }
203

                            
                        
204
    function _sub(uint256 a, uint256 b) internal pure returns (uint256) {
205
        require(a >= b, "ERC20: subtraction underflow");
206
        return a - b;
207
    }
208

                            
                        
209
    /*//////////////////////////////////////////////////////////////
210
                                HELPERS
211
    //////////////////////////////////////////////////////////////*/
212

                            
                        
213
    // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
214
    // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
215
    // can't simply access the chain ID in a normal view or pure function because the solc View Pure
216
    // Checker changed `chainid` from pure to view in 0.8.0.
217
    function _viewChainId() private view returns (uint256 chainId) {
218
        // Assembly required since `block.chainid` was introduced in 0.8.0.
219
        assembly {
220
            chainId := chainid()
221
        }
222

                            
                        
223
        address(this); // Silence warnings in older Solc versions.
224
    }
225

                            
                        
226
    function _pureChainId() private pure returns (uint256 chainId) {
227
        function() internal view returns (uint256) fnIn = _viewChainId;
228
        function() internal pure returns (uint256) pureChainId;
229
        assembly {
230
            pureChainId := fnIn
231
        }
232
        chainId = pureChainId();
233
    }
234
}
235

                            
                        

Lines covered: 0 / 45 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
import {IERC721Metadata, IERC721TokenReceiver} from "../interfaces/IERC721.sol";
5

                            
                        
6
/// @notice This is a mock contract of the ERC721 standard for testing purposes only, it SHOULD NOT be used in production.
7
/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC721.sol
8
contract MockERC721 is IERC721Metadata {
9
    /*//////////////////////////////////////////////////////////////
10
                         METADATA STORAGE/LOGIC
11
    //////////////////////////////////////////////////////////////*/
12

                            
                        
13
    string internal _name;
14

                            
                        
15
    string internal _symbol;
16

                            
                        
17
    function name() external view override returns (string memory) {
18
        return _name;
19
    }
20

                            
                        
21
    function symbol() external view override returns (string memory) {
22
        return _symbol;
23
    }
24

                            
                        
25
    function tokenURI(uint256 id) public view virtual override returns (string memory) {}
26

                            
                        
27
    /*//////////////////////////////////////////////////////////////
28
                      ERC721 BALANCE/OWNER STORAGE
29
    //////////////////////////////////////////////////////////////*/
30

                            
                        
31
    mapping(uint256 => address) internal _ownerOf;
32

                            
                        
33
    mapping(address => uint256) internal _balanceOf;
34

                            
                        
35
    function ownerOf(uint256 id) public view virtual override returns (address owner) {
36
        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
37
    }
38

                            
                        
39
    function balanceOf(address owner) public view virtual override returns (uint256) {
40
        require(owner != address(0), "ZERO_ADDRESS");
41

                            
                        
42
        return _balanceOf[owner];
43
    }
44

                            
                        
45
    /*//////////////////////////////////////////////////////////////
46
                         ERC721 APPROVAL STORAGE
47
    //////////////////////////////////////////////////////////////*/
48

                            
                        
49
    mapping(uint256 => address) internal _getApproved;
50

                            
                        
51
    mapping(address => mapping(address => bool)) internal _isApprovedForAll;
52

                            
                        
53
    function getApproved(uint256 id) public view virtual override returns (address) {
54
        return _getApproved[id];
55
    }
56

                            
                        
57
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
58
        return _isApprovedForAll[owner][operator];
59
    }
60

                            
                        
61
    /*//////////////////////////////////////////////////////////////
62
                               INITIALIZE
63
    //////////////////////////////////////////////////////////////*/
64

                            
                        
65
    /// @dev A bool to track whether the contract has been initialized.
66
    bool private initialized;
67

                            
                        
68
    /// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and
69
    /// syntaxes, we add an initialization function that can be called only once.
70
    function initialize(string memory name_, string memory symbol_) public {
71
        require(!initialized, "ALREADY_INITIALIZED");
72

                            
                        
73
        _name = name_;
74
        _symbol = symbol_;
75

                            
                        
76
        initialized = true;
77
    }
78

                            
                        
79
    /*//////////////////////////////////////////////////////////////
80
                              ERC721 LOGIC
81
    //////////////////////////////////////////////////////////////*/
82

                            
                        
83
    function approve(address spender, uint256 id) public payable virtual override {
84
        address owner = _ownerOf[id];
85

                            
                        
86
        require(msg.sender == owner || _isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
87

                            
                        
88
        _getApproved[id] = spender;
89

                            
                        
90
        emit Approval(owner, spender, id);
91
    }
92

                            
                        
93
    function setApprovalForAll(address operator, bool approved) public virtual override {
94
        _isApprovedForAll[msg.sender][operator] = approved;
95

                            
                        
96
        emit ApprovalForAll(msg.sender, operator, approved);
97
    }
98

                            
                        
99
    function transferFrom(address from, address to, uint256 id) public payable virtual override {
100
        require(from == _ownerOf[id], "WRONG_FROM");
101

                            
                        
102
        require(to != address(0), "INVALID_RECIPIENT");
103

                            
                        
104
        require(
105
            msg.sender == from || _isApprovedForAll[from][msg.sender] || msg.sender == _getApproved[id],
106
            "NOT_AUTHORIZED"
107
        );
108

                            
                        
109
        // Underflow of the sender's balance is impossible because we check for
110
        // ownership above and the recipient's balance can't realistically overflow.
111
        _balanceOf[from]--;
112

                            
                        
113
        _balanceOf[to]++;
114

                            
                        
115
        _ownerOf[id] = to;
116

                            
                        
117
        delete _getApproved[id];
118

                            
                        
119
        emit Transfer(from, to, id);
120
    }
121

                            
                        
122
    function safeTransferFrom(address from, address to, uint256 id) public payable virtual override {
123
        transferFrom(from, to, id);
124

                            
                        
125
        require(
126
            !_isContract(to)
127
                || IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "")
128
                    == IERC721TokenReceiver.onERC721Received.selector,
129
            "UNSAFE_RECIPIENT"
130
        );
131
    }
132

                            
                        
133
    function safeTransferFrom(address from, address to, uint256 id, bytes memory data)
134
        public
135
        payable
136
        virtual
137
        override
138
    {
139
        transferFrom(from, to, id);
140

                            
                        
141
        require(
142
            !_isContract(to)
143
                || IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data)
144
                    == IERC721TokenReceiver.onERC721Received.selector,
145
            "UNSAFE_RECIPIENT"
146
        );
147
    }
148

                            
                        
149
    /*//////////////////////////////////////////////////////////////
150
                              ERC165 LOGIC
151
    //////////////////////////////////////////////////////////////*/
152

                            
                        
153
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
154
        return interfaceId == 0x01ffc9a7 // ERC165 Interface ID for ERC165
155
            || interfaceId == 0x80ac58cd // ERC165 Interface ID for ERC721
156
            || interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
157
    }
158

                            
                        
159
    /*//////////////////////////////////////////////////////////////
160
                        INTERNAL MINT/BURN LOGIC
161
    //////////////////////////////////////////////////////////////*/
162

                            
                        
163
    function _mint(address to, uint256 id) internal virtual {
164
        require(to != address(0), "INVALID_RECIPIENT");
165

                            
                        
166
        require(_ownerOf[id] == address(0), "ALREADY_MINTED");
167

                            
                        
168
        // Counter overflow is incredibly unrealistic.
169

                            
                        
170
        _balanceOf[to]++;
171

                            
                        
172
        _ownerOf[id] = to;
173

                            
                        
174
        emit Transfer(address(0), to, id);
175
    }
176

                            
                        
177
    function _burn(uint256 id) internal virtual {
178
        address owner = _ownerOf[id];
179

                            
                        
180
        require(owner != address(0), "NOT_MINTED");
181

                            
                        
182
        _balanceOf[owner]--;
183

                            
                        
184
        delete _ownerOf[id];
185

                            
                        
186
        delete _getApproved[id];
187

                            
                        
188
        emit Transfer(owner, address(0), id);
189
    }
190

                            
                        
191
    /*//////////////////////////////////////////////////////////////
192
                        INTERNAL SAFE MINT LOGIC
193
    //////////////////////////////////////////////////////////////*/
194

                            
                        
195
    function _safeMint(address to, uint256 id) internal virtual {
196
        _mint(to, id);
197

                            
                        
198
        require(
199
            !_isContract(to)
200
                || IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "")
201
                    == IERC721TokenReceiver.onERC721Received.selector,
202
            "UNSAFE_RECIPIENT"
203
        );
204
    }
205

                            
                        
206
    function _safeMint(address to, uint256 id, bytes memory data) internal virtual {
207
        _mint(to, id);
208

                            
                        
209
        require(
210
            !_isContract(to)
211
                || IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data)
212
                    == IERC721TokenReceiver.onERC721Received.selector,
213
            "UNSAFE_RECIPIENT"
214
        );
215
    }
216

                            
                        
217
    /*//////////////////////////////////////////////////////////////
218
                                HELPERS
219
    //////////////////////////////////////////////////////////////*/
220

                            
                        
221
    function _isContract(address _addr) private view returns (bool) {
222
        uint256 codeLength;
223

                            
                        
224
        // Assembly required for versions < 0.8.0 to check extcodesize.
225
        assembly {
226
            codeLength := extcodesize(_addr)
227
        }
228

                            
                        
229
        return codeLength > 0;
230
    }
231
}
232

                            
                        

Lines covered: 0 / 1 (0.0%)

1
// SPDX-License-Identifier: MIT
2
pragma solidity >=0.6.2 <0.9.0;
3

                            
                        
4
/// @author philogy <https://github.com/philogy>
5
/// @dev Code generated automatically by script.
6
library safeconsole {
7
    uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;
8

                            
                        
9
    // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)
10
    // for the view-to-pure log trick.
11
    function _sendLogPayload(uint256 offset, uint256 size) private pure {
12
        function(uint256, uint256) internal view fnIn = _sendLogPayloadView;
13
        function(uint256, uint256) internal pure pureSendLogPayload;
14
        /// @solidity memory-safe-assembly
15
        assembly {
16
            pureSendLogPayload := fnIn
17
        }
18
        pureSendLogPayload(offset, size);
19
    }
20

                            
                        
21
    function _sendLogPayloadView(uint256 offset, uint256 size) private view {
22
        /// @solidity memory-safe-assembly
23
        assembly {
24
            pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))
25
        }
26
    }
27

                            
                        
28
    function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {
29
        function(uint256, uint256, uint256) internal view fnIn = _memcopyView;
30
        function(uint256, uint256, uint256) internal pure pureMemcopy;
31
        /// @solidity memory-safe-assembly
32
        assembly {
33
            pureMemcopy := fnIn
34
        }
35
        pureMemcopy(fromOffset, toOffset, length);
36
    }
37

                            
                        
38
    function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {
39
        /// @solidity memory-safe-assembly
40
        assembly {
41
            pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))
42
        }
43
    }
44

                            
                        
45
    function logMemory(uint256 offset, uint256 length) internal pure {
46
        if (offset >= 0x60) {
47
            // Sufficient memory before slice to prepare call header.
48
            bytes32 m0;
49
            bytes32 m1;
50
            bytes32 m2;
51
            /// @solidity memory-safe-assembly
52
            assembly {
53
                m0 := mload(sub(offset, 0x60))
54
                m1 := mload(sub(offset, 0x40))
55
                m2 := mload(sub(offset, 0x20))
56
                // Selector of `log(bytes)`.
57
                mstore(sub(offset, 0x60), 0x0be77f56)
58
                mstore(sub(offset, 0x40), 0x20)
59
                mstore(sub(offset, 0x20), length)
60
            }
61
            _sendLogPayload(offset - 0x44, length + 0x44);
62
            /// @solidity memory-safe-assembly
63
            assembly {
64
                mstore(sub(offset, 0x60), m0)
65
                mstore(sub(offset, 0x40), m1)
66
                mstore(sub(offset, 0x20), m2)
67
            }
68
        } else {
69
            // Insufficient space, so copy slice forward, add header and reverse.
70
            bytes32 m0;
71
            bytes32 m1;
72
            bytes32 m2;
73
            uint256 endOffset = offset + length;
74
            /// @solidity memory-safe-assembly
75
            assembly {
76
                m0 := mload(add(endOffset, 0x00))
77
                m1 := mload(add(endOffset, 0x20))
78
                m2 := mload(add(endOffset, 0x40))
79
            }
80
            _memcopy(offset, offset + 0x60, length);
81
            /// @solidity memory-safe-assembly
82
            assembly {
83
                // Selector of `log(bytes)`.
84
                mstore(add(offset, 0x00), 0x0be77f56)
85
                mstore(add(offset, 0x20), 0x20)
86
                mstore(add(offset, 0x40), length)
87
            }
88
            _sendLogPayload(offset + 0x1c, length + 0x44);
89
            _memcopy(offset + 0x60, offset, length);
90
            /// @solidity memory-safe-assembly
91
            assembly {
92
                mstore(add(endOffset, 0x00), m0)
93
                mstore(add(endOffset, 0x20), m1)
94
                mstore(add(endOffset, 0x40), m2)
95
            }
96
        }
97
    }
98

                            
                        
99
    function log(address p0) internal pure {
100
        bytes32 m0;
101
        bytes32 m1;
102
        /// @solidity memory-safe-assembly
103
        assembly {
104
            m0 := mload(0x00)
105
            m1 := mload(0x20)
106
            // Selector of `log(address)`.
107
            mstore(0x00, 0x2c2ecbc2)
108
            mstore(0x20, p0)
109
        }
110
        _sendLogPayload(0x1c, 0x24);
111
        /// @solidity memory-safe-assembly
112
        assembly {
113
            mstore(0x00, m0)
114
            mstore(0x20, m1)
115
        }
116
    }
117

                            
                        
118
    function log(bool p0) internal pure {
119
        bytes32 m0;
120
        bytes32 m1;
121
        /// @solidity memory-safe-assembly
122
        assembly {
123
            m0 := mload(0x00)
124
            m1 := mload(0x20)
125
            // Selector of `log(bool)`.
126
            mstore(0x00, 0x32458eed)
127
            mstore(0x20, p0)
128
        }
129
        _sendLogPayload(0x1c, 0x24);
130
        /// @solidity memory-safe-assembly
131
        assembly {
132
            mstore(0x00, m0)
133
            mstore(0x20, m1)
134
        }
135
    }
136

                            
                        
137
    function log(uint256 p0) internal pure {
138
        bytes32 m0;
139
        bytes32 m1;
140
        /// @solidity memory-safe-assembly
141
        assembly {
142
            m0 := mload(0x00)
143
            m1 := mload(0x20)
144
            // Selector of `log(uint256)`.
145
            mstore(0x00, 0xf82c50f1)
146
            mstore(0x20, p0)
147
        }
148
        _sendLogPayload(0x1c, 0x24);
149
        /// @solidity memory-safe-assembly
150
        assembly {
151
            mstore(0x00, m0)
152
            mstore(0x20, m1)
153
        }
154
    }
155

                            
                        
156
    function log(bytes32 p0) internal pure {
157
        bytes32 m0;
158
        bytes32 m1;
159
        bytes32 m2;
160
        bytes32 m3;
161
        /// @solidity memory-safe-assembly
162
        assembly {
163
            function writeString(pos, w) {
164
                let length := 0
165
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
166
                mstore(pos, length)
167
                let shift := sub(256, shl(3, length))
168
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
169
            }
170
            m0 := mload(0x00)
171
            m1 := mload(0x20)
172
            m2 := mload(0x40)
173
            m3 := mload(0x60)
174
            // Selector of `log(string)`.
175
            mstore(0x00, 0x41304fac)
176
            mstore(0x20, 0x20)
177
            writeString(0x40, p0)
178
        }
179
        _sendLogPayload(0x1c, 0x64);
180
        /// @solidity memory-safe-assembly
181
        assembly {
182
            mstore(0x00, m0)
183
            mstore(0x20, m1)
184
            mstore(0x40, m2)
185
            mstore(0x60, m3)
186
        }
187
    }
188

                            
                        
189
    function log(address p0, address p1) internal pure {
190
        bytes32 m0;
191
        bytes32 m1;
192
        bytes32 m2;
193
        /// @solidity memory-safe-assembly
194
        assembly {
195
            m0 := mload(0x00)
196
            m1 := mload(0x20)
197
            m2 := mload(0x40)
198
            // Selector of `log(address,address)`.
199
            mstore(0x00, 0xdaf0d4aa)
200
            mstore(0x20, p0)
201
            mstore(0x40, p1)
202
        }
203
        _sendLogPayload(0x1c, 0x44);
204
        /// @solidity memory-safe-assembly
205
        assembly {
206
            mstore(0x00, m0)
207
            mstore(0x20, m1)
208
            mstore(0x40, m2)
209
        }
210
    }
211

                            
                        
212
    function log(address p0, bool p1) internal pure {
213
        bytes32 m0;
214
        bytes32 m1;
215
        bytes32 m2;
216
        /// @solidity memory-safe-assembly
217
        assembly {
218
            m0 := mload(0x00)
219
            m1 := mload(0x20)
220
            m2 := mload(0x40)
221
            // Selector of `log(address,bool)`.
222
            mstore(0x00, 0x75b605d3)
223
            mstore(0x20, p0)
224
            mstore(0x40, p1)
225
        }
226
        _sendLogPayload(0x1c, 0x44);
227
        /// @solidity memory-safe-assembly
228
        assembly {
229
            mstore(0x00, m0)
230
            mstore(0x20, m1)
231
            mstore(0x40, m2)
232
        }
233
    }
234

                            
                        
235
    function log(address p0, uint256 p1) internal pure {
236
        bytes32 m0;
237
        bytes32 m1;
238
        bytes32 m2;
239
        /// @solidity memory-safe-assembly
240
        assembly {
241
            m0 := mload(0x00)
242
            m1 := mload(0x20)
243
            m2 := mload(0x40)
244
            // Selector of `log(address,uint256)`.
245
            mstore(0x00, 0x8309e8a8)
246
            mstore(0x20, p0)
247
            mstore(0x40, p1)
248
        }
249
        _sendLogPayload(0x1c, 0x44);
250
        /// @solidity memory-safe-assembly
251
        assembly {
252
            mstore(0x00, m0)
253
            mstore(0x20, m1)
254
            mstore(0x40, m2)
255
        }
256
    }
257

                            
                        
258
    function log(address p0, bytes32 p1) internal pure {
259
        bytes32 m0;
260
        bytes32 m1;
261
        bytes32 m2;
262
        bytes32 m3;
263
        bytes32 m4;
264
        /// @solidity memory-safe-assembly
265
        assembly {
266
            function writeString(pos, w) {
267
                let length := 0
268
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
269
                mstore(pos, length)
270
                let shift := sub(256, shl(3, length))
271
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
272
            }
273
            m0 := mload(0x00)
274
            m1 := mload(0x20)
275
            m2 := mload(0x40)
276
            m3 := mload(0x60)
277
            m4 := mload(0x80)
278
            // Selector of `log(address,string)`.
279
            mstore(0x00, 0x759f86bb)
280
            mstore(0x20, p0)
281
            mstore(0x40, 0x40)
282
            writeString(0x60, p1)
283
        }
284
        _sendLogPayload(0x1c, 0x84);
285
        /// @solidity memory-safe-assembly
286
        assembly {
287
            mstore(0x00, m0)
288
            mstore(0x20, m1)
289
            mstore(0x40, m2)
290
            mstore(0x60, m3)
291
            mstore(0x80, m4)
292
        }
293
    }
294

                            
                        
295
    function log(bool p0, address p1) internal pure {
296
        bytes32 m0;
297
        bytes32 m1;
298
        bytes32 m2;
299
        /// @solidity memory-safe-assembly
300
        assembly {
301
            m0 := mload(0x00)
302
            m1 := mload(0x20)
303
            m2 := mload(0x40)
304
            // Selector of `log(bool,address)`.
305
            mstore(0x00, 0x853c4849)
306
            mstore(0x20, p0)
307
            mstore(0x40, p1)
308
        }
309
        _sendLogPayload(0x1c, 0x44);
310
        /// @solidity memory-safe-assembly
311
        assembly {
312
            mstore(0x00, m0)
313
            mstore(0x20, m1)
314
            mstore(0x40, m2)
315
        }
316
    }
317

                            
                        
318
    function log(bool p0, bool p1) internal pure {
319
        bytes32 m0;
320
        bytes32 m1;
321
        bytes32 m2;
322
        /// @solidity memory-safe-assembly
323
        assembly {
324
            m0 := mload(0x00)
325
            m1 := mload(0x20)
326
            m2 := mload(0x40)
327
            // Selector of `log(bool,bool)`.
328
            mstore(0x00, 0x2a110e83)
329
            mstore(0x20, p0)
330
            mstore(0x40, p1)
331
        }
332
        _sendLogPayload(0x1c, 0x44);
333
        /// @solidity memory-safe-assembly
334
        assembly {
335
            mstore(0x00, m0)
336
            mstore(0x20, m1)
337
            mstore(0x40, m2)
338
        }
339
    }
340

                            
                        
341
    function log(bool p0, uint256 p1) internal pure {
342
        bytes32 m0;
343
        bytes32 m1;
344
        bytes32 m2;
345
        /// @solidity memory-safe-assembly
346
        assembly {
347
            m0 := mload(0x00)
348
            m1 := mload(0x20)
349
            m2 := mload(0x40)
350
            // Selector of `log(bool,uint256)`.
351
            mstore(0x00, 0x399174d3)
352
            mstore(0x20, p0)
353
            mstore(0x40, p1)
354
        }
355
        _sendLogPayload(0x1c, 0x44);
356
        /// @solidity memory-safe-assembly
357
        assembly {
358
            mstore(0x00, m0)
359
            mstore(0x20, m1)
360
            mstore(0x40, m2)
361
        }
362
    }
363

                            
                        
364
    function log(bool p0, bytes32 p1) internal pure {
365
        bytes32 m0;
366
        bytes32 m1;
367
        bytes32 m2;
368
        bytes32 m3;
369
        bytes32 m4;
370
        /// @solidity memory-safe-assembly
371
        assembly {
372
            function writeString(pos, w) {
373
                let length := 0
374
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
375
                mstore(pos, length)
376
                let shift := sub(256, shl(3, length))
377
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
378
            }
379
            m0 := mload(0x00)
380
            m1 := mload(0x20)
381
            m2 := mload(0x40)
382
            m3 := mload(0x60)
383
            m4 := mload(0x80)
384
            // Selector of `log(bool,string)`.
385
            mstore(0x00, 0x8feac525)
386
            mstore(0x20, p0)
387
            mstore(0x40, 0x40)
388
            writeString(0x60, p1)
389
        }
390
        _sendLogPayload(0x1c, 0x84);
391
        /// @solidity memory-safe-assembly
392
        assembly {
393
            mstore(0x00, m0)
394
            mstore(0x20, m1)
395
            mstore(0x40, m2)
396
            mstore(0x60, m3)
397
            mstore(0x80, m4)
398
        }
399
    }
400

                            
                        
401
    function log(uint256 p0, address p1) internal pure {
402
        bytes32 m0;
403
        bytes32 m1;
404
        bytes32 m2;
405
        /// @solidity memory-safe-assembly
406
        assembly {
407
            m0 := mload(0x00)
408
            m1 := mload(0x20)
409
            m2 := mload(0x40)
410
            // Selector of `log(uint256,address)`.
411
            mstore(0x00, 0x69276c86)
412
            mstore(0x20, p0)
413
            mstore(0x40, p1)
414
        }
415
        _sendLogPayload(0x1c, 0x44);
416
        /// @solidity memory-safe-assembly
417
        assembly {
418
            mstore(0x00, m0)
419
            mstore(0x20, m1)
420
            mstore(0x40, m2)
421
        }
422
    }
423

                            
                        
424
    function log(uint256 p0, bool p1) internal pure {
425
        bytes32 m0;
426
        bytes32 m1;
427
        bytes32 m2;
428
        /// @solidity memory-safe-assembly
429
        assembly {
430
            m0 := mload(0x00)
431
            m1 := mload(0x20)
432
            m2 := mload(0x40)
433
            // Selector of `log(uint256,bool)`.
434
            mstore(0x00, 0x1c9d7eb3)
435
            mstore(0x20, p0)
436
            mstore(0x40, p1)
437
        }
438
        _sendLogPayload(0x1c, 0x44);
439
        /// @solidity memory-safe-assembly
440
        assembly {
441
            mstore(0x00, m0)
442
            mstore(0x20, m1)
443
            mstore(0x40, m2)
444
        }
445
    }
446

                            
                        
447
    function log(uint256 p0, uint256 p1) internal pure {
448
        bytes32 m0;
449
        bytes32 m1;
450
        bytes32 m2;
451
        /// @solidity memory-safe-assembly
452
        assembly {
453
            m0 := mload(0x00)
454
            m1 := mload(0x20)
455
            m2 := mload(0x40)
456
            // Selector of `log(uint256,uint256)`.
457
            mstore(0x00, 0xf666715a)
458
            mstore(0x20, p0)
459
            mstore(0x40, p1)
460
        }
461
        _sendLogPayload(0x1c, 0x44);
462
        /// @solidity memory-safe-assembly
463
        assembly {
464
            mstore(0x00, m0)
465
            mstore(0x20, m1)
466
            mstore(0x40, m2)
467
        }
468
    }
469

                            
                        
470
    function log(uint256 p0, bytes32 p1) internal pure {
471
        bytes32 m0;
472
        bytes32 m1;
473
        bytes32 m2;
474
        bytes32 m3;
475
        bytes32 m4;
476
        /// @solidity memory-safe-assembly
477
        assembly {
478
            function writeString(pos, w) {
479
                let length := 0
480
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
481
                mstore(pos, length)
482
                let shift := sub(256, shl(3, length))
483
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
484
            }
485
            m0 := mload(0x00)
486
            m1 := mload(0x20)
487
            m2 := mload(0x40)
488
            m3 := mload(0x60)
489
            m4 := mload(0x80)
490
            // Selector of `log(uint256,string)`.
491
            mstore(0x00, 0x643fd0df)
492
            mstore(0x20, p0)
493
            mstore(0x40, 0x40)
494
            writeString(0x60, p1)
495
        }
496
        _sendLogPayload(0x1c, 0x84);
497
        /// @solidity memory-safe-assembly
498
        assembly {
499
            mstore(0x00, m0)
500
            mstore(0x20, m1)
501
            mstore(0x40, m2)
502
            mstore(0x60, m3)
503
            mstore(0x80, m4)
504
        }
505
    }
506

                            
                        
507
    function log(bytes32 p0, address p1) internal pure {
508
        bytes32 m0;
509
        bytes32 m1;
510
        bytes32 m2;
511
        bytes32 m3;
512
        bytes32 m4;
513
        /// @solidity memory-safe-assembly
514
        assembly {
515
            function writeString(pos, w) {
516
                let length := 0
517
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
518
                mstore(pos, length)
519
                let shift := sub(256, shl(3, length))
520
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
521
            }
522
            m0 := mload(0x00)
523
            m1 := mload(0x20)
524
            m2 := mload(0x40)
525
            m3 := mload(0x60)
526
            m4 := mload(0x80)
527
            // Selector of `log(string,address)`.
528
            mstore(0x00, 0x319af333)
529
            mstore(0x20, 0x40)
530
            mstore(0x40, p1)
531
            writeString(0x60, p0)
532
        }
533
        _sendLogPayload(0x1c, 0x84);
534
        /// @solidity memory-safe-assembly
535
        assembly {
536
            mstore(0x00, m0)
537
            mstore(0x20, m1)
538
            mstore(0x40, m2)
539
            mstore(0x60, m3)
540
            mstore(0x80, m4)
541
        }
542
    }
543

                            
                        
544
    function log(bytes32 p0, bool p1) internal pure {
545
        bytes32 m0;
546
        bytes32 m1;
547
        bytes32 m2;
548
        bytes32 m3;
549
        bytes32 m4;
550
        /// @solidity memory-safe-assembly
551
        assembly {
552
            function writeString(pos, w) {
553
                let length := 0
554
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
555
                mstore(pos, length)
556
                let shift := sub(256, shl(3, length))
557
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
558
            }
559
            m0 := mload(0x00)
560
            m1 := mload(0x20)
561
            m2 := mload(0x40)
562
            m3 := mload(0x60)
563
            m4 := mload(0x80)
564
            // Selector of `log(string,bool)`.
565
            mstore(0x00, 0xc3b55635)
566
            mstore(0x20, 0x40)
567
            mstore(0x40, p1)
568
            writeString(0x60, p0)
569
        }
570
        _sendLogPayload(0x1c, 0x84);
571
        /// @solidity memory-safe-assembly
572
        assembly {
573
            mstore(0x00, m0)
574
            mstore(0x20, m1)
575
            mstore(0x40, m2)
576
            mstore(0x60, m3)
577
            mstore(0x80, m4)
578
        }
579
    }
580

                            
                        
581
    function log(bytes32 p0, uint256 p1) internal pure {
582
        bytes32 m0;
583
        bytes32 m1;
584
        bytes32 m2;
585
        bytes32 m3;
586
        bytes32 m4;
587
        /// @solidity memory-safe-assembly
588
        assembly {
589
            function writeString(pos, w) {
590
                let length := 0
591
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
592
                mstore(pos, length)
593
                let shift := sub(256, shl(3, length))
594
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
595
            }
596
            m0 := mload(0x00)
597
            m1 := mload(0x20)
598
            m2 := mload(0x40)
599
            m3 := mload(0x60)
600
            m4 := mload(0x80)
601
            // Selector of `log(string,uint256)`.
602
            mstore(0x00, 0xb60e72cc)
603
            mstore(0x20, 0x40)
604
            mstore(0x40, p1)
605
            writeString(0x60, p0)
606
        }
607
        _sendLogPayload(0x1c, 0x84);
608
        /// @solidity memory-safe-assembly
609
        assembly {
610
            mstore(0x00, m0)
611
            mstore(0x20, m1)
612
            mstore(0x40, m2)
613
            mstore(0x60, m3)
614
            mstore(0x80, m4)
615
        }
616
    }
617

                            
                        
618
    function log(bytes32 p0, bytes32 p1) internal pure {
619
        bytes32 m0;
620
        bytes32 m1;
621
        bytes32 m2;
622
        bytes32 m3;
623
        bytes32 m4;
624
        bytes32 m5;
625
        bytes32 m6;
626
        /// @solidity memory-safe-assembly
627
        assembly {
628
            function writeString(pos, w) {
629
                let length := 0
630
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
631
                mstore(pos, length)
632
                let shift := sub(256, shl(3, length))
633
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
634
            }
635
            m0 := mload(0x00)
636
            m1 := mload(0x20)
637
            m2 := mload(0x40)
638
            m3 := mload(0x60)
639
            m4 := mload(0x80)
640
            m5 := mload(0xa0)
641
            m6 := mload(0xc0)
642
            // Selector of `log(string,string)`.
643
            mstore(0x00, 0x4b5c4277)
644
            mstore(0x20, 0x40)
645
            mstore(0x40, 0x80)
646
            writeString(0x60, p0)
647
            writeString(0xa0, p1)
648
        }
649
        _sendLogPayload(0x1c, 0xc4);
650
        /// @solidity memory-safe-assembly
651
        assembly {
652
            mstore(0x00, m0)
653
            mstore(0x20, m1)
654
            mstore(0x40, m2)
655
            mstore(0x60, m3)
656
            mstore(0x80, m4)
657
            mstore(0xa0, m5)
658
            mstore(0xc0, m6)
659
        }
660
    }
661

                            
                        
662
    function log(address p0, address p1, address p2) internal pure {
663
        bytes32 m0;
664
        bytes32 m1;
665
        bytes32 m2;
666
        bytes32 m3;
667
        /// @solidity memory-safe-assembly
668
        assembly {
669
            m0 := mload(0x00)
670
            m1 := mload(0x20)
671
            m2 := mload(0x40)
672
            m3 := mload(0x60)
673
            // Selector of `log(address,address,address)`.
674
            mstore(0x00, 0x018c84c2)
675
            mstore(0x20, p0)
676
            mstore(0x40, p1)
677
            mstore(0x60, p2)
678
        }
679
        _sendLogPayload(0x1c, 0x64);
680
        /// @solidity memory-safe-assembly
681
        assembly {
682
            mstore(0x00, m0)
683
            mstore(0x20, m1)
684
            mstore(0x40, m2)
685
            mstore(0x60, m3)
686
        }
687
    }
688

                            
                        
689
    function log(address p0, address p1, bool p2) internal pure {
690
        bytes32 m0;
691
        bytes32 m1;
692
        bytes32 m2;
693
        bytes32 m3;
694
        /// @solidity memory-safe-assembly
695
        assembly {
696
            m0 := mload(0x00)
697
            m1 := mload(0x20)
698
            m2 := mload(0x40)
699
            m3 := mload(0x60)
700
            // Selector of `log(address,address,bool)`.
701
            mstore(0x00, 0xf2a66286)
702
            mstore(0x20, p0)
703
            mstore(0x40, p1)
704
            mstore(0x60, p2)
705
        }
706
        _sendLogPayload(0x1c, 0x64);
707
        /// @solidity memory-safe-assembly
708
        assembly {
709
            mstore(0x00, m0)
710
            mstore(0x20, m1)
711
            mstore(0x40, m2)
712
            mstore(0x60, m3)
713
        }
714
    }
715

                            
                        
716
    function log(address p0, address p1, uint256 p2) internal pure {
717
        bytes32 m0;
718
        bytes32 m1;
719
        bytes32 m2;
720
        bytes32 m3;
721
        /// @solidity memory-safe-assembly
722
        assembly {
723
            m0 := mload(0x00)
724
            m1 := mload(0x20)
725
            m2 := mload(0x40)
726
            m3 := mload(0x60)
727
            // Selector of `log(address,address,uint256)`.
728
            mstore(0x00, 0x17fe6185)
729
            mstore(0x20, p0)
730
            mstore(0x40, p1)
731
            mstore(0x60, p2)
732
        }
733
        _sendLogPayload(0x1c, 0x64);
734
        /// @solidity memory-safe-assembly
735
        assembly {
736
            mstore(0x00, m0)
737
            mstore(0x20, m1)
738
            mstore(0x40, m2)
739
            mstore(0x60, m3)
740
        }
741
    }
742

                            
                        
743
    function log(address p0, address p1, bytes32 p2) internal pure {
744
        bytes32 m0;
745
        bytes32 m1;
746
        bytes32 m2;
747
        bytes32 m3;
748
        bytes32 m4;
749
        bytes32 m5;
750
        /// @solidity memory-safe-assembly
751
        assembly {
752
            function writeString(pos, w) {
753
                let length := 0
754
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
755
                mstore(pos, length)
756
                let shift := sub(256, shl(3, length))
757
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
758
            }
759
            m0 := mload(0x00)
760
            m1 := mload(0x20)
761
            m2 := mload(0x40)
762
            m3 := mload(0x60)
763
            m4 := mload(0x80)
764
            m5 := mload(0xa0)
765
            // Selector of `log(address,address,string)`.
766
            mstore(0x00, 0x007150be)
767
            mstore(0x20, p0)
768
            mstore(0x40, p1)
769
            mstore(0x60, 0x60)
770
            writeString(0x80, p2)
771
        }
772
        _sendLogPayload(0x1c, 0xa4);
773
        /// @solidity memory-safe-assembly
774
        assembly {
775
            mstore(0x00, m0)
776
            mstore(0x20, m1)
777
            mstore(0x40, m2)
778
            mstore(0x60, m3)
779
            mstore(0x80, m4)
780
            mstore(0xa0, m5)
781
        }
782
    }
783

                            
                        
784
    function log(address p0, bool p1, address p2) internal pure {
785
        bytes32 m0;
786
        bytes32 m1;
787
        bytes32 m2;
788
        bytes32 m3;
789
        /// @solidity memory-safe-assembly
790
        assembly {
791
            m0 := mload(0x00)
792
            m1 := mload(0x20)
793
            m2 := mload(0x40)
794
            m3 := mload(0x60)
795
            // Selector of `log(address,bool,address)`.
796
            mstore(0x00, 0xf11699ed)
797
            mstore(0x20, p0)
798
            mstore(0x40, p1)
799
            mstore(0x60, p2)
800
        }
801
        _sendLogPayload(0x1c, 0x64);
802
        /// @solidity memory-safe-assembly
803
        assembly {
804
            mstore(0x00, m0)
805
            mstore(0x20, m1)
806
            mstore(0x40, m2)
807
            mstore(0x60, m3)
808
        }
809
    }
810

                            
                        
811
    function log(address p0, bool p1, bool p2) internal pure {
812
        bytes32 m0;
813
        bytes32 m1;
814
        bytes32 m2;
815
        bytes32 m3;
816
        /// @solidity memory-safe-assembly
817
        assembly {
818
            m0 := mload(0x00)
819
            m1 := mload(0x20)
820
            m2 := mload(0x40)
821
            m3 := mload(0x60)
822
            // Selector of `log(address,bool,bool)`.
823
            mstore(0x00, 0xeb830c92)
824
            mstore(0x20, p0)
825
            mstore(0x40, p1)
826
            mstore(0x60, p2)
827
        }
828
        _sendLogPayload(0x1c, 0x64);
829
        /// @solidity memory-safe-assembly
830
        assembly {
831
            mstore(0x00, m0)
832
            mstore(0x20, m1)
833
            mstore(0x40, m2)
834
            mstore(0x60, m3)
835
        }
836
    }
837

                            
                        
838
    function log(address p0, bool p1, uint256 p2) internal pure {
839
        bytes32 m0;
840
        bytes32 m1;
841
        bytes32 m2;
842
        bytes32 m3;
843
        /// @solidity memory-safe-assembly
844
        assembly {
845
            m0 := mload(0x00)
846
            m1 := mload(0x20)
847
            m2 := mload(0x40)
848
            m3 := mload(0x60)
849
            // Selector of `log(address,bool,uint256)`.
850
            mstore(0x00, 0x9c4f99fb)
851
            mstore(0x20, p0)
852
            mstore(0x40, p1)
853
            mstore(0x60, p2)
854
        }
855
        _sendLogPayload(0x1c, 0x64);
856
        /// @solidity memory-safe-assembly
857
        assembly {
858
            mstore(0x00, m0)
859
            mstore(0x20, m1)
860
            mstore(0x40, m2)
861
            mstore(0x60, m3)
862
        }
863
    }
864

                            
                        
865
    function log(address p0, bool p1, bytes32 p2) internal pure {
866
        bytes32 m0;
867
        bytes32 m1;
868
        bytes32 m2;
869
        bytes32 m3;
870
        bytes32 m4;
871
        bytes32 m5;
872
        /// @solidity memory-safe-assembly
873
        assembly {
874
            function writeString(pos, w) {
875
                let length := 0
876
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
877
                mstore(pos, length)
878
                let shift := sub(256, shl(3, length))
879
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
880
            }
881
            m0 := mload(0x00)
882
            m1 := mload(0x20)
883
            m2 := mload(0x40)
884
            m3 := mload(0x60)
885
            m4 := mload(0x80)
886
            m5 := mload(0xa0)
887
            // Selector of `log(address,bool,string)`.
888
            mstore(0x00, 0x212255cc)
889
            mstore(0x20, p0)
890
            mstore(0x40, p1)
891
            mstore(0x60, 0x60)
892
            writeString(0x80, p2)
893
        }
894
        _sendLogPayload(0x1c, 0xa4);
895
        /// @solidity memory-safe-assembly
896
        assembly {
897
            mstore(0x00, m0)
898
            mstore(0x20, m1)
899
            mstore(0x40, m2)
900
            mstore(0x60, m3)
901
            mstore(0x80, m4)
902
            mstore(0xa0, m5)
903
        }
904
    }
905

                            
                        
906
    function log(address p0, uint256 p1, address p2) internal pure {
907
        bytes32 m0;
908
        bytes32 m1;
909
        bytes32 m2;
910
        bytes32 m3;
911
        /// @solidity memory-safe-assembly
912
        assembly {
913
            m0 := mload(0x00)
914
            m1 := mload(0x20)
915
            m2 := mload(0x40)
916
            m3 := mload(0x60)
917
            // Selector of `log(address,uint256,address)`.
918
            mstore(0x00, 0x7bc0d848)
919
            mstore(0x20, p0)
920
            mstore(0x40, p1)
921
            mstore(0x60, p2)
922
        }
923
        _sendLogPayload(0x1c, 0x64);
924
        /// @solidity memory-safe-assembly
925
        assembly {
926
            mstore(0x00, m0)
927
            mstore(0x20, m1)
928
            mstore(0x40, m2)
929
            mstore(0x60, m3)
930
        }
931
    }
932

                            
                        
933
    function log(address p0, uint256 p1, bool p2) internal pure {
934
        bytes32 m0;
935
        bytes32 m1;
936
        bytes32 m2;
937
        bytes32 m3;
938
        /// @solidity memory-safe-assembly
939
        assembly {
940
            m0 := mload(0x00)
941
            m1 := mload(0x20)
942
            m2 := mload(0x40)
943
            m3 := mload(0x60)
944
            // Selector of `log(address,uint256,bool)`.
945
            mstore(0x00, 0x678209a8)
946
            mstore(0x20, p0)
947
            mstore(0x40, p1)
948
            mstore(0x60, p2)
949
        }
950
        _sendLogPayload(0x1c, 0x64);
951
        /// @solidity memory-safe-assembly
952
        assembly {
953
            mstore(0x00, m0)
954
            mstore(0x20, m1)
955
            mstore(0x40, m2)
956
            mstore(0x60, m3)
957
        }
958
    }
959

                            
                        
960
    function log(address p0, uint256 p1, uint256 p2) internal pure {
961
        bytes32 m0;
962
        bytes32 m1;
963
        bytes32 m2;
964
        bytes32 m3;
965
        /// @solidity memory-safe-assembly
966
        assembly {
967
            m0 := mload(0x00)
968
            m1 := mload(0x20)
969
            m2 := mload(0x40)
970
            m3 := mload(0x60)
971
            // Selector of `log(address,uint256,uint256)`.
972
            mstore(0x00, 0xb69bcaf6)
973
            mstore(0x20, p0)
974
            mstore(0x40, p1)
975
            mstore(0x60, p2)
976
        }
977
        _sendLogPayload(0x1c, 0x64);
978
        /// @solidity memory-safe-assembly
979
        assembly {
980
            mstore(0x00, m0)
981
            mstore(0x20, m1)
982
            mstore(0x40, m2)
983
            mstore(0x60, m3)
984
        }
985
    }
986

                            
                        
987
    function log(address p0, uint256 p1, bytes32 p2) internal pure {
988
        bytes32 m0;
989
        bytes32 m1;
990
        bytes32 m2;
991
        bytes32 m3;
992
        bytes32 m4;
993
        bytes32 m5;
994
        /// @solidity memory-safe-assembly
995
        assembly {
996
            function writeString(pos, w) {
997
                let length := 0
998
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
999
                mstore(pos, length)
1000
                let shift := sub(256, shl(3, length))
1001
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1002
            }
1003
            m0 := mload(0x00)
1004
            m1 := mload(0x20)
1005
            m2 := mload(0x40)
1006
            m3 := mload(0x60)
1007
            m4 := mload(0x80)
1008
            m5 := mload(0xa0)
1009
            // Selector of `log(address,uint256,string)`.
1010
            mstore(0x00, 0xa1f2e8aa)
1011
            mstore(0x20, p0)
1012
            mstore(0x40, p1)
1013
            mstore(0x60, 0x60)
1014
            writeString(0x80, p2)
1015
        }
1016
        _sendLogPayload(0x1c, 0xa4);
1017
        /// @solidity memory-safe-assembly
1018
        assembly {
1019
            mstore(0x00, m0)
1020
            mstore(0x20, m1)
1021
            mstore(0x40, m2)
1022
            mstore(0x60, m3)
1023
            mstore(0x80, m4)
1024
            mstore(0xa0, m5)
1025
        }
1026
    }
1027

                            
                        
1028
    function log(address p0, bytes32 p1, address p2) internal pure {
1029
        bytes32 m0;
1030
        bytes32 m1;
1031
        bytes32 m2;
1032
        bytes32 m3;
1033
        bytes32 m4;
1034
        bytes32 m5;
1035
        /// @solidity memory-safe-assembly
1036
        assembly {
1037
            function writeString(pos, w) {
1038
                let length := 0
1039
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1040
                mstore(pos, length)
1041
                let shift := sub(256, shl(3, length))
1042
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1043
            }
1044
            m0 := mload(0x00)
1045
            m1 := mload(0x20)
1046
            m2 := mload(0x40)
1047
            m3 := mload(0x60)
1048
            m4 := mload(0x80)
1049
            m5 := mload(0xa0)
1050
            // Selector of `log(address,string,address)`.
1051
            mstore(0x00, 0xf08744e8)
1052
            mstore(0x20, p0)
1053
            mstore(0x40, 0x60)
1054
            mstore(0x60, p2)
1055
            writeString(0x80, p1)
1056
        }
1057
        _sendLogPayload(0x1c, 0xa4);
1058
        /// @solidity memory-safe-assembly
1059
        assembly {
1060
            mstore(0x00, m0)
1061
            mstore(0x20, m1)
1062
            mstore(0x40, m2)
1063
            mstore(0x60, m3)
1064
            mstore(0x80, m4)
1065
            mstore(0xa0, m5)
1066
        }
1067
    }
1068

                            
                        
1069
    function log(address p0, bytes32 p1, bool p2) internal pure {
1070
        bytes32 m0;
1071
        bytes32 m1;
1072
        bytes32 m2;
1073
        bytes32 m3;
1074
        bytes32 m4;
1075
        bytes32 m5;
1076
        /// @solidity memory-safe-assembly
1077
        assembly {
1078
            function writeString(pos, w) {
1079
                let length := 0
1080
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1081
                mstore(pos, length)
1082
                let shift := sub(256, shl(3, length))
1083
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1084
            }
1085
            m0 := mload(0x00)
1086
            m1 := mload(0x20)
1087
            m2 := mload(0x40)
1088
            m3 := mload(0x60)
1089
            m4 := mload(0x80)
1090
            m5 := mload(0xa0)
1091
            // Selector of `log(address,string,bool)`.
1092
            mstore(0x00, 0xcf020fb1)
1093
            mstore(0x20, p0)
1094
            mstore(0x40, 0x60)
1095
            mstore(0x60, p2)
1096
            writeString(0x80, p1)
1097
        }
1098
        _sendLogPayload(0x1c, 0xa4);
1099
        /// @solidity memory-safe-assembly
1100
        assembly {
1101
            mstore(0x00, m0)
1102
            mstore(0x20, m1)
1103
            mstore(0x40, m2)
1104
            mstore(0x60, m3)
1105
            mstore(0x80, m4)
1106
            mstore(0xa0, m5)
1107
        }
1108
    }
1109

                            
                        
1110
    function log(address p0, bytes32 p1, uint256 p2) internal pure {
1111
        bytes32 m0;
1112
        bytes32 m1;
1113
        bytes32 m2;
1114
        bytes32 m3;
1115
        bytes32 m4;
1116
        bytes32 m5;
1117
        /// @solidity memory-safe-assembly
1118
        assembly {
1119
            function writeString(pos, w) {
1120
                let length := 0
1121
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1122
                mstore(pos, length)
1123
                let shift := sub(256, shl(3, length))
1124
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1125
            }
1126
            m0 := mload(0x00)
1127
            m1 := mload(0x20)
1128
            m2 := mload(0x40)
1129
            m3 := mload(0x60)
1130
            m4 := mload(0x80)
1131
            m5 := mload(0xa0)
1132
            // Selector of `log(address,string,uint256)`.
1133
            mstore(0x00, 0x67dd6ff1)
1134
            mstore(0x20, p0)
1135
            mstore(0x40, 0x60)
1136
            mstore(0x60, p2)
1137
            writeString(0x80, p1)
1138
        }
1139
        _sendLogPayload(0x1c, 0xa4);
1140
        /// @solidity memory-safe-assembly
1141
        assembly {
1142
            mstore(0x00, m0)
1143
            mstore(0x20, m1)
1144
            mstore(0x40, m2)
1145
            mstore(0x60, m3)
1146
            mstore(0x80, m4)
1147
            mstore(0xa0, m5)
1148
        }
1149
    }
1150

                            
                        
1151
    function log(address p0, bytes32 p1, bytes32 p2) internal pure {
1152
        bytes32 m0;
1153
        bytes32 m1;
1154
        bytes32 m2;
1155
        bytes32 m3;
1156
        bytes32 m4;
1157
        bytes32 m5;
1158
        bytes32 m6;
1159
        bytes32 m7;
1160
        /// @solidity memory-safe-assembly
1161
        assembly {
1162
            function writeString(pos, w) {
1163
                let length := 0
1164
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1165
                mstore(pos, length)
1166
                let shift := sub(256, shl(3, length))
1167
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1168
            }
1169
            m0 := mload(0x00)
1170
            m1 := mload(0x20)
1171
            m2 := mload(0x40)
1172
            m3 := mload(0x60)
1173
            m4 := mload(0x80)
1174
            m5 := mload(0xa0)
1175
            m6 := mload(0xc0)
1176
            m7 := mload(0xe0)
1177
            // Selector of `log(address,string,string)`.
1178
            mstore(0x00, 0xfb772265)
1179
            mstore(0x20, p0)
1180
            mstore(0x40, 0x60)
1181
            mstore(0x60, 0xa0)
1182
            writeString(0x80, p1)
1183
            writeString(0xc0, p2)
1184
        }
1185
        _sendLogPayload(0x1c, 0xe4);
1186
        /// @solidity memory-safe-assembly
1187
        assembly {
1188
            mstore(0x00, m0)
1189
            mstore(0x20, m1)
1190
            mstore(0x40, m2)
1191
            mstore(0x60, m3)
1192
            mstore(0x80, m4)
1193
            mstore(0xa0, m5)
1194
            mstore(0xc0, m6)
1195
            mstore(0xe0, m7)
1196
        }
1197
    }
1198

                            
                        
1199
    function log(bool p0, address p1, address p2) internal pure {
1200
        bytes32 m0;
1201
        bytes32 m1;
1202
        bytes32 m2;
1203
        bytes32 m3;
1204
        /// @solidity memory-safe-assembly
1205
        assembly {
1206
            m0 := mload(0x00)
1207
            m1 := mload(0x20)
1208
            m2 := mload(0x40)
1209
            m3 := mload(0x60)
1210
            // Selector of `log(bool,address,address)`.
1211
            mstore(0x00, 0xd2763667)
1212
            mstore(0x20, p0)
1213
            mstore(0x40, p1)
1214
            mstore(0x60, p2)
1215
        }
1216
        _sendLogPayload(0x1c, 0x64);
1217
        /// @solidity memory-safe-assembly
1218
        assembly {
1219
            mstore(0x00, m0)
1220
            mstore(0x20, m1)
1221
            mstore(0x40, m2)
1222
            mstore(0x60, m3)
1223
        }
1224
    }
1225

                            
                        
1226
    function log(bool p0, address p1, bool p2) internal pure {
1227
        bytes32 m0;
1228
        bytes32 m1;
1229
        bytes32 m2;
1230
        bytes32 m3;
1231
        /// @solidity memory-safe-assembly
1232
        assembly {
1233
            m0 := mload(0x00)
1234
            m1 := mload(0x20)
1235
            m2 := mload(0x40)
1236
            m3 := mload(0x60)
1237
            // Selector of `log(bool,address,bool)`.
1238
            mstore(0x00, 0x18c9c746)
1239
            mstore(0x20, p0)
1240
            mstore(0x40, p1)
1241
            mstore(0x60, p2)
1242
        }
1243
        _sendLogPayload(0x1c, 0x64);
1244
        /// @solidity memory-safe-assembly
1245
        assembly {
1246
            mstore(0x00, m0)
1247
            mstore(0x20, m1)
1248
            mstore(0x40, m2)
1249
            mstore(0x60, m3)
1250
        }
1251
    }
1252

                            
                        
1253
    function log(bool p0, address p1, uint256 p2) internal pure {
1254
        bytes32 m0;
1255
        bytes32 m1;
1256
        bytes32 m2;
1257
        bytes32 m3;
1258
        /// @solidity memory-safe-assembly
1259
        assembly {
1260
            m0 := mload(0x00)
1261
            m1 := mload(0x20)
1262
            m2 := mload(0x40)
1263
            m3 := mload(0x60)
1264
            // Selector of `log(bool,address,uint256)`.
1265
            mstore(0x00, 0x5f7b9afb)
1266
            mstore(0x20, p0)
1267
            mstore(0x40, p1)
1268
            mstore(0x60, p2)
1269
        }
1270
        _sendLogPayload(0x1c, 0x64);
1271
        /// @solidity memory-safe-assembly
1272
        assembly {
1273
            mstore(0x00, m0)
1274
            mstore(0x20, m1)
1275
            mstore(0x40, m2)
1276
            mstore(0x60, m3)
1277
        }
1278
    }
1279

                            
                        
1280
    function log(bool p0, address p1, bytes32 p2) internal pure {
1281
        bytes32 m0;
1282
        bytes32 m1;
1283
        bytes32 m2;
1284
        bytes32 m3;
1285
        bytes32 m4;
1286
        bytes32 m5;
1287
        /// @solidity memory-safe-assembly
1288
        assembly {
1289
            function writeString(pos, w) {
1290
                let length := 0
1291
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1292
                mstore(pos, length)
1293
                let shift := sub(256, shl(3, length))
1294
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1295
            }
1296
            m0 := mload(0x00)
1297
            m1 := mload(0x20)
1298
            m2 := mload(0x40)
1299
            m3 := mload(0x60)
1300
            m4 := mload(0x80)
1301
            m5 := mload(0xa0)
1302
            // Selector of `log(bool,address,string)`.
1303
            mstore(0x00, 0xde9a9270)
1304
            mstore(0x20, p0)
1305
            mstore(0x40, p1)
1306
            mstore(0x60, 0x60)
1307
            writeString(0x80, p2)
1308
        }
1309
        _sendLogPayload(0x1c, 0xa4);
1310
        /// @solidity memory-safe-assembly
1311
        assembly {
1312
            mstore(0x00, m0)
1313
            mstore(0x20, m1)
1314
            mstore(0x40, m2)
1315
            mstore(0x60, m3)
1316
            mstore(0x80, m4)
1317
            mstore(0xa0, m5)
1318
        }
1319
    }
1320

                            
                        
1321
    function log(bool p0, bool p1, address p2) internal pure {
1322
        bytes32 m0;
1323
        bytes32 m1;
1324
        bytes32 m2;
1325
        bytes32 m3;
1326
        /// @solidity memory-safe-assembly
1327
        assembly {
1328
            m0 := mload(0x00)
1329
            m1 := mload(0x20)
1330
            m2 := mload(0x40)
1331
            m3 := mload(0x60)
1332
            // Selector of `log(bool,bool,address)`.
1333
            mstore(0x00, 0x1078f68d)
1334
            mstore(0x20, p0)
1335
            mstore(0x40, p1)
1336
            mstore(0x60, p2)
1337
        }
1338
        _sendLogPayload(0x1c, 0x64);
1339
        /// @solidity memory-safe-assembly
1340
        assembly {
1341
            mstore(0x00, m0)
1342
            mstore(0x20, m1)
1343
            mstore(0x40, m2)
1344
            mstore(0x60, m3)
1345
        }
1346
    }
1347

                            
                        
1348
    function log(bool p0, bool p1, bool p2) internal pure {
1349
        bytes32 m0;
1350
        bytes32 m1;
1351
        bytes32 m2;
1352
        bytes32 m3;
1353
        /// @solidity memory-safe-assembly
1354
        assembly {
1355
            m0 := mload(0x00)
1356
            m1 := mload(0x20)
1357
            m2 := mload(0x40)
1358
            m3 := mload(0x60)
1359
            // Selector of `log(bool,bool,bool)`.
1360
            mstore(0x00, 0x50709698)
1361
            mstore(0x20, p0)
1362
            mstore(0x40, p1)
1363
            mstore(0x60, p2)
1364
        }
1365
        _sendLogPayload(0x1c, 0x64);
1366
        /// @solidity memory-safe-assembly
1367
        assembly {
1368
            mstore(0x00, m0)
1369
            mstore(0x20, m1)
1370
            mstore(0x40, m2)
1371
            mstore(0x60, m3)
1372
        }
1373
    }
1374

                            
                        
1375
    function log(bool p0, bool p1, uint256 p2) internal pure {
1376
        bytes32 m0;
1377
        bytes32 m1;
1378
        bytes32 m2;
1379
        bytes32 m3;
1380
        /// @solidity memory-safe-assembly
1381
        assembly {
1382
            m0 := mload(0x00)
1383
            m1 := mload(0x20)
1384
            m2 := mload(0x40)
1385
            m3 := mload(0x60)
1386
            // Selector of `log(bool,bool,uint256)`.
1387
            mstore(0x00, 0x12f21602)
1388
            mstore(0x20, p0)
1389
            mstore(0x40, p1)
1390
            mstore(0x60, p2)
1391
        }
1392
        _sendLogPayload(0x1c, 0x64);
1393
        /// @solidity memory-safe-assembly
1394
        assembly {
1395
            mstore(0x00, m0)
1396
            mstore(0x20, m1)
1397
            mstore(0x40, m2)
1398
            mstore(0x60, m3)
1399
        }
1400
    }
1401

                            
                        
1402
    function log(bool p0, bool p1, bytes32 p2) internal pure {
1403
        bytes32 m0;
1404
        bytes32 m1;
1405
        bytes32 m2;
1406
        bytes32 m3;
1407
        bytes32 m4;
1408
        bytes32 m5;
1409
        /// @solidity memory-safe-assembly
1410
        assembly {
1411
            function writeString(pos, w) {
1412
                let length := 0
1413
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1414
                mstore(pos, length)
1415
                let shift := sub(256, shl(3, length))
1416
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1417
            }
1418
            m0 := mload(0x00)
1419
            m1 := mload(0x20)
1420
            m2 := mload(0x40)
1421
            m3 := mload(0x60)
1422
            m4 := mload(0x80)
1423
            m5 := mload(0xa0)
1424
            // Selector of `log(bool,bool,string)`.
1425
            mstore(0x00, 0x2555fa46)
1426
            mstore(0x20, p0)
1427
            mstore(0x40, p1)
1428
            mstore(0x60, 0x60)
1429
            writeString(0x80, p2)
1430
        }
1431
        _sendLogPayload(0x1c, 0xa4);
1432
        /// @solidity memory-safe-assembly
1433
        assembly {
1434
            mstore(0x00, m0)
1435
            mstore(0x20, m1)
1436
            mstore(0x40, m2)
1437
            mstore(0x60, m3)
1438
            mstore(0x80, m4)
1439
            mstore(0xa0, m5)
1440
        }
1441
    }
1442

                            
                        
1443
    function log(bool p0, uint256 p1, address p2) internal pure {
1444
        bytes32 m0;
1445
        bytes32 m1;
1446
        bytes32 m2;
1447
        bytes32 m3;
1448
        /// @solidity memory-safe-assembly
1449
        assembly {
1450
            m0 := mload(0x00)
1451
            m1 := mload(0x20)
1452
            m2 := mload(0x40)
1453
            m3 := mload(0x60)
1454
            // Selector of `log(bool,uint256,address)`.
1455
            mstore(0x00, 0x088ef9d2)
1456
            mstore(0x20, p0)
1457
            mstore(0x40, p1)
1458
            mstore(0x60, p2)
1459
        }
1460
        _sendLogPayload(0x1c, 0x64);
1461
        /// @solidity memory-safe-assembly
1462
        assembly {
1463
            mstore(0x00, m0)
1464
            mstore(0x20, m1)
1465
            mstore(0x40, m2)
1466
            mstore(0x60, m3)
1467
        }
1468
    }
1469

                            
                        
1470
    function log(bool p0, uint256 p1, bool p2) internal pure {
1471
        bytes32 m0;
1472
        bytes32 m1;
1473
        bytes32 m2;
1474
        bytes32 m3;
1475
        /// @solidity memory-safe-assembly
1476
        assembly {
1477
            m0 := mload(0x00)
1478
            m1 := mload(0x20)
1479
            m2 := mload(0x40)
1480
            m3 := mload(0x60)
1481
            // Selector of `log(bool,uint256,bool)`.
1482
            mstore(0x00, 0xe8defba9)
1483
            mstore(0x20, p0)
1484
            mstore(0x40, p1)
1485
            mstore(0x60, p2)
1486
        }
1487
        _sendLogPayload(0x1c, 0x64);
1488
        /// @solidity memory-safe-assembly
1489
        assembly {
1490
            mstore(0x00, m0)
1491
            mstore(0x20, m1)
1492
            mstore(0x40, m2)
1493
            mstore(0x60, m3)
1494
        }
1495
    }
1496

                            
                        
1497
    function log(bool p0, uint256 p1, uint256 p2) internal pure {
1498
        bytes32 m0;
1499
        bytes32 m1;
1500
        bytes32 m2;
1501
        bytes32 m3;
1502
        /// @solidity memory-safe-assembly
1503
        assembly {
1504
            m0 := mload(0x00)
1505
            m1 := mload(0x20)
1506
            m2 := mload(0x40)
1507
            m3 := mload(0x60)
1508
            // Selector of `log(bool,uint256,uint256)`.
1509
            mstore(0x00, 0x37103367)
1510
            mstore(0x20, p0)
1511
            mstore(0x40, p1)
1512
            mstore(0x60, p2)
1513
        }
1514
        _sendLogPayload(0x1c, 0x64);
1515
        /// @solidity memory-safe-assembly
1516
        assembly {
1517
            mstore(0x00, m0)
1518
            mstore(0x20, m1)
1519
            mstore(0x40, m2)
1520
            mstore(0x60, m3)
1521
        }
1522
    }
1523

                            
                        
1524
    function log(bool p0, uint256 p1, bytes32 p2) internal pure {
1525
        bytes32 m0;
1526
        bytes32 m1;
1527
        bytes32 m2;
1528
        bytes32 m3;
1529
        bytes32 m4;
1530
        bytes32 m5;
1531
        /// @solidity memory-safe-assembly
1532
        assembly {
1533
            function writeString(pos, w) {
1534
                let length := 0
1535
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1536
                mstore(pos, length)
1537
                let shift := sub(256, shl(3, length))
1538
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1539
            }
1540
            m0 := mload(0x00)
1541
            m1 := mload(0x20)
1542
            m2 := mload(0x40)
1543
            m3 := mload(0x60)
1544
            m4 := mload(0x80)
1545
            m5 := mload(0xa0)
1546
            // Selector of `log(bool,uint256,string)`.
1547
            mstore(0x00, 0xc3fc3970)
1548
            mstore(0x20, p0)
1549
            mstore(0x40, p1)
1550
            mstore(0x60, 0x60)
1551
            writeString(0x80, p2)
1552
        }
1553
        _sendLogPayload(0x1c, 0xa4);
1554
        /// @solidity memory-safe-assembly
1555
        assembly {
1556
            mstore(0x00, m0)
1557
            mstore(0x20, m1)
1558
            mstore(0x40, m2)
1559
            mstore(0x60, m3)
1560
            mstore(0x80, m4)
1561
            mstore(0xa0, m5)
1562
        }
1563
    }
1564

                            
                        
1565
    function log(bool p0, bytes32 p1, address p2) internal pure {
1566
        bytes32 m0;
1567
        bytes32 m1;
1568
        bytes32 m2;
1569
        bytes32 m3;
1570
        bytes32 m4;
1571
        bytes32 m5;
1572
        /// @solidity memory-safe-assembly
1573
        assembly {
1574
            function writeString(pos, w) {
1575
                let length := 0
1576
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1577
                mstore(pos, length)
1578
                let shift := sub(256, shl(3, length))
1579
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1580
            }
1581
            m0 := mload(0x00)
1582
            m1 := mload(0x20)
1583
            m2 := mload(0x40)
1584
            m3 := mload(0x60)
1585
            m4 := mload(0x80)
1586
            m5 := mload(0xa0)
1587
            // Selector of `log(bool,string,address)`.
1588
            mstore(0x00, 0x9591b953)
1589
            mstore(0x20, p0)
1590
            mstore(0x40, 0x60)
1591
            mstore(0x60, p2)
1592
            writeString(0x80, p1)
1593
        }
1594
        _sendLogPayload(0x1c, 0xa4);
1595
        /// @solidity memory-safe-assembly
1596
        assembly {
1597
            mstore(0x00, m0)
1598
            mstore(0x20, m1)
1599
            mstore(0x40, m2)
1600
            mstore(0x60, m3)
1601
            mstore(0x80, m4)
1602
            mstore(0xa0, m5)
1603
        }
1604
    }
1605

                            
                        
1606
    function log(bool p0, bytes32 p1, bool p2) internal pure {
1607
        bytes32 m0;
1608
        bytes32 m1;
1609
        bytes32 m2;
1610
        bytes32 m3;
1611
        bytes32 m4;
1612
        bytes32 m5;
1613
        /// @solidity memory-safe-assembly
1614
        assembly {
1615
            function writeString(pos, w) {
1616
                let length := 0
1617
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1618
                mstore(pos, length)
1619
                let shift := sub(256, shl(3, length))
1620
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1621
            }
1622
            m0 := mload(0x00)
1623
            m1 := mload(0x20)
1624
            m2 := mload(0x40)
1625
            m3 := mload(0x60)
1626
            m4 := mload(0x80)
1627
            m5 := mload(0xa0)
1628
            // Selector of `log(bool,string,bool)`.
1629
            mstore(0x00, 0xdbb4c247)
1630
            mstore(0x20, p0)
1631
            mstore(0x40, 0x60)
1632
            mstore(0x60, p2)
1633
            writeString(0x80, p1)
1634
        }
1635
        _sendLogPayload(0x1c, 0xa4);
1636
        /// @solidity memory-safe-assembly
1637
        assembly {
1638
            mstore(0x00, m0)
1639
            mstore(0x20, m1)
1640
            mstore(0x40, m2)
1641
            mstore(0x60, m3)
1642
            mstore(0x80, m4)
1643
            mstore(0xa0, m5)
1644
        }
1645
    }
1646

                            
                        
1647
    function log(bool p0, bytes32 p1, uint256 p2) internal pure {
1648
        bytes32 m0;
1649
        bytes32 m1;
1650
        bytes32 m2;
1651
        bytes32 m3;
1652
        bytes32 m4;
1653
        bytes32 m5;
1654
        /// @solidity memory-safe-assembly
1655
        assembly {
1656
            function writeString(pos, w) {
1657
                let length := 0
1658
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1659
                mstore(pos, length)
1660
                let shift := sub(256, shl(3, length))
1661
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1662
            }
1663
            m0 := mload(0x00)
1664
            m1 := mload(0x20)
1665
            m2 := mload(0x40)
1666
            m3 := mload(0x60)
1667
            m4 := mload(0x80)
1668
            m5 := mload(0xa0)
1669
            // Selector of `log(bool,string,uint256)`.
1670
            mstore(0x00, 0x1093ee11)
1671
            mstore(0x20, p0)
1672
            mstore(0x40, 0x60)
1673
            mstore(0x60, p2)
1674
            writeString(0x80, p1)
1675
        }
1676
        _sendLogPayload(0x1c, 0xa4);
1677
        /// @solidity memory-safe-assembly
1678
        assembly {
1679
            mstore(0x00, m0)
1680
            mstore(0x20, m1)
1681
            mstore(0x40, m2)
1682
            mstore(0x60, m3)
1683
            mstore(0x80, m4)
1684
            mstore(0xa0, m5)
1685
        }
1686
    }
1687

                            
                        
1688
    function log(bool p0, bytes32 p1, bytes32 p2) internal pure {
1689
        bytes32 m0;
1690
        bytes32 m1;
1691
        bytes32 m2;
1692
        bytes32 m3;
1693
        bytes32 m4;
1694
        bytes32 m5;
1695
        bytes32 m6;
1696
        bytes32 m7;
1697
        /// @solidity memory-safe-assembly
1698
        assembly {
1699
            function writeString(pos, w) {
1700
                let length := 0
1701
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1702
                mstore(pos, length)
1703
                let shift := sub(256, shl(3, length))
1704
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1705
            }
1706
            m0 := mload(0x00)
1707
            m1 := mload(0x20)
1708
            m2 := mload(0x40)
1709
            m3 := mload(0x60)
1710
            m4 := mload(0x80)
1711
            m5 := mload(0xa0)
1712
            m6 := mload(0xc0)
1713
            m7 := mload(0xe0)
1714
            // Selector of `log(bool,string,string)`.
1715
            mstore(0x00, 0xb076847f)
1716
            mstore(0x20, p0)
1717
            mstore(0x40, 0x60)
1718
            mstore(0x60, 0xa0)
1719
            writeString(0x80, p1)
1720
            writeString(0xc0, p2)
1721
        }
1722
        _sendLogPayload(0x1c, 0xe4);
1723
        /// @solidity memory-safe-assembly
1724
        assembly {
1725
            mstore(0x00, m0)
1726
            mstore(0x20, m1)
1727
            mstore(0x40, m2)
1728
            mstore(0x60, m3)
1729
            mstore(0x80, m4)
1730
            mstore(0xa0, m5)
1731
            mstore(0xc0, m6)
1732
            mstore(0xe0, m7)
1733
        }
1734
    }
1735

                            
                        
1736
    function log(uint256 p0, address p1, address p2) internal pure {
1737
        bytes32 m0;
1738
        bytes32 m1;
1739
        bytes32 m2;
1740
        bytes32 m3;
1741
        /// @solidity memory-safe-assembly
1742
        assembly {
1743
            m0 := mload(0x00)
1744
            m1 := mload(0x20)
1745
            m2 := mload(0x40)
1746
            m3 := mload(0x60)
1747
            // Selector of `log(uint256,address,address)`.
1748
            mstore(0x00, 0xbcfd9be0)
1749
            mstore(0x20, p0)
1750
            mstore(0x40, p1)
1751
            mstore(0x60, p2)
1752
        }
1753
        _sendLogPayload(0x1c, 0x64);
1754
        /// @solidity memory-safe-assembly
1755
        assembly {
1756
            mstore(0x00, m0)
1757
            mstore(0x20, m1)
1758
            mstore(0x40, m2)
1759
            mstore(0x60, m3)
1760
        }
1761
    }
1762

                            
                        
1763
    function log(uint256 p0, address p1, bool p2) internal pure {
1764
        bytes32 m0;
1765
        bytes32 m1;
1766
        bytes32 m2;
1767
        bytes32 m3;
1768
        /// @solidity memory-safe-assembly
1769
        assembly {
1770
            m0 := mload(0x00)
1771
            m1 := mload(0x20)
1772
            m2 := mload(0x40)
1773
            m3 := mload(0x60)
1774
            // Selector of `log(uint256,address,bool)`.
1775
            mstore(0x00, 0x9b6ec042)
1776
            mstore(0x20, p0)
1777
            mstore(0x40, p1)
1778
            mstore(0x60, p2)
1779
        }
1780
        _sendLogPayload(0x1c, 0x64);
1781
        /// @solidity memory-safe-assembly
1782
        assembly {
1783
            mstore(0x00, m0)
1784
            mstore(0x20, m1)
1785
            mstore(0x40, m2)
1786
            mstore(0x60, m3)
1787
        }
1788
    }
1789

                            
                        
1790
    function log(uint256 p0, address p1, uint256 p2) internal pure {
1791
        bytes32 m0;
1792
        bytes32 m1;
1793
        bytes32 m2;
1794
        bytes32 m3;
1795
        /// @solidity memory-safe-assembly
1796
        assembly {
1797
            m0 := mload(0x00)
1798
            m1 := mload(0x20)
1799
            m2 := mload(0x40)
1800
            m3 := mload(0x60)
1801
            // Selector of `log(uint256,address,uint256)`.
1802
            mstore(0x00, 0x5a9b5ed5)
1803
            mstore(0x20, p0)
1804
            mstore(0x40, p1)
1805
            mstore(0x60, p2)
1806
        }
1807
        _sendLogPayload(0x1c, 0x64);
1808
        /// @solidity memory-safe-assembly
1809
        assembly {
1810
            mstore(0x00, m0)
1811
            mstore(0x20, m1)
1812
            mstore(0x40, m2)
1813
            mstore(0x60, m3)
1814
        }
1815
    }
1816

                            
                        
1817
    function log(uint256 p0, address p1, bytes32 p2) internal pure {
1818
        bytes32 m0;
1819
        bytes32 m1;
1820
        bytes32 m2;
1821
        bytes32 m3;
1822
        bytes32 m4;
1823
        bytes32 m5;
1824
        /// @solidity memory-safe-assembly
1825
        assembly {
1826
            function writeString(pos, w) {
1827
                let length := 0
1828
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1829
                mstore(pos, length)
1830
                let shift := sub(256, shl(3, length))
1831
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1832
            }
1833
            m0 := mload(0x00)
1834
            m1 := mload(0x20)
1835
            m2 := mload(0x40)
1836
            m3 := mload(0x60)
1837
            m4 := mload(0x80)
1838
            m5 := mload(0xa0)
1839
            // Selector of `log(uint256,address,string)`.
1840
            mstore(0x00, 0x63cb41f9)
1841
            mstore(0x20, p0)
1842
            mstore(0x40, p1)
1843
            mstore(0x60, 0x60)
1844
            writeString(0x80, p2)
1845
        }
1846
        _sendLogPayload(0x1c, 0xa4);
1847
        /// @solidity memory-safe-assembly
1848
        assembly {
1849
            mstore(0x00, m0)
1850
            mstore(0x20, m1)
1851
            mstore(0x40, m2)
1852
            mstore(0x60, m3)
1853
            mstore(0x80, m4)
1854
            mstore(0xa0, m5)
1855
        }
1856
    }
1857

                            
                        
1858
    function log(uint256 p0, bool p1, address p2) internal pure {
1859
        bytes32 m0;
1860
        bytes32 m1;
1861
        bytes32 m2;
1862
        bytes32 m3;
1863
        /// @solidity memory-safe-assembly
1864
        assembly {
1865
            m0 := mload(0x00)
1866
            m1 := mload(0x20)
1867
            m2 := mload(0x40)
1868
            m3 := mload(0x60)
1869
            // Selector of `log(uint256,bool,address)`.
1870
            mstore(0x00, 0x35085f7b)
1871
            mstore(0x20, p0)
1872
            mstore(0x40, p1)
1873
            mstore(0x60, p2)
1874
        }
1875
        _sendLogPayload(0x1c, 0x64);
1876
        /// @solidity memory-safe-assembly
1877
        assembly {
1878
            mstore(0x00, m0)
1879
            mstore(0x20, m1)
1880
            mstore(0x40, m2)
1881
            mstore(0x60, m3)
1882
        }
1883
    }
1884

                            
                        
1885
    function log(uint256 p0, bool p1, bool p2) internal pure {
1886
        bytes32 m0;
1887
        bytes32 m1;
1888
        bytes32 m2;
1889
        bytes32 m3;
1890
        /// @solidity memory-safe-assembly
1891
        assembly {
1892
            m0 := mload(0x00)
1893
            m1 := mload(0x20)
1894
            m2 := mload(0x40)
1895
            m3 := mload(0x60)
1896
            // Selector of `log(uint256,bool,bool)`.
1897
            mstore(0x00, 0x20718650)
1898
            mstore(0x20, p0)
1899
            mstore(0x40, p1)
1900
            mstore(0x60, p2)
1901
        }
1902
        _sendLogPayload(0x1c, 0x64);
1903
        /// @solidity memory-safe-assembly
1904
        assembly {
1905
            mstore(0x00, m0)
1906
            mstore(0x20, m1)
1907
            mstore(0x40, m2)
1908
            mstore(0x60, m3)
1909
        }
1910
    }
1911

                            
                        
1912
    function log(uint256 p0, bool p1, uint256 p2) internal pure {
1913
        bytes32 m0;
1914
        bytes32 m1;
1915
        bytes32 m2;
1916
        bytes32 m3;
1917
        /// @solidity memory-safe-assembly
1918
        assembly {
1919
            m0 := mload(0x00)
1920
            m1 := mload(0x20)
1921
            m2 := mload(0x40)
1922
            m3 := mload(0x60)
1923
            // Selector of `log(uint256,bool,uint256)`.
1924
            mstore(0x00, 0x20098014)
1925
            mstore(0x20, p0)
1926
            mstore(0x40, p1)
1927
            mstore(0x60, p2)
1928
        }
1929
        _sendLogPayload(0x1c, 0x64);
1930
        /// @solidity memory-safe-assembly
1931
        assembly {
1932
            mstore(0x00, m0)
1933
            mstore(0x20, m1)
1934
            mstore(0x40, m2)
1935
            mstore(0x60, m3)
1936
        }
1937
    }
1938

                            
                        
1939
    function log(uint256 p0, bool p1, bytes32 p2) internal pure {
1940
        bytes32 m0;
1941
        bytes32 m1;
1942
        bytes32 m2;
1943
        bytes32 m3;
1944
        bytes32 m4;
1945
        bytes32 m5;
1946
        /// @solidity memory-safe-assembly
1947
        assembly {
1948
            function writeString(pos, w) {
1949
                let length := 0
1950
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
1951
                mstore(pos, length)
1952
                let shift := sub(256, shl(3, length))
1953
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
1954
            }
1955
            m0 := mload(0x00)
1956
            m1 := mload(0x20)
1957
            m2 := mload(0x40)
1958
            m3 := mload(0x60)
1959
            m4 := mload(0x80)
1960
            m5 := mload(0xa0)
1961
            // Selector of `log(uint256,bool,string)`.
1962
            mstore(0x00, 0x85775021)
1963
            mstore(0x20, p0)
1964
            mstore(0x40, p1)
1965
            mstore(0x60, 0x60)
1966
            writeString(0x80, p2)
1967
        }
1968
        _sendLogPayload(0x1c, 0xa4);
1969
        /// @solidity memory-safe-assembly
1970
        assembly {
1971
            mstore(0x00, m0)
1972
            mstore(0x20, m1)
1973
            mstore(0x40, m2)
1974
            mstore(0x60, m3)
1975
            mstore(0x80, m4)
1976
            mstore(0xa0, m5)
1977
        }
1978
    }
1979

                            
                        
1980
    function log(uint256 p0, uint256 p1, address p2) internal pure {
1981
        bytes32 m0;
1982
        bytes32 m1;
1983
        bytes32 m2;
1984
        bytes32 m3;
1985
        /// @solidity memory-safe-assembly
1986
        assembly {
1987
            m0 := mload(0x00)
1988
            m1 := mload(0x20)
1989
            m2 := mload(0x40)
1990
            m3 := mload(0x60)
1991
            // Selector of `log(uint256,uint256,address)`.
1992
            mstore(0x00, 0x5c96b331)
1993
            mstore(0x20, p0)
1994
            mstore(0x40, p1)
1995
            mstore(0x60, p2)
1996
        }
1997
        _sendLogPayload(0x1c, 0x64);
1998
        /// @solidity memory-safe-assembly
1999
        assembly {
2000
            mstore(0x00, m0)
2001
            mstore(0x20, m1)
2002
            mstore(0x40, m2)
2003
            mstore(0x60, m3)
2004
        }
2005
    }
2006

                            
                        
2007
    function log(uint256 p0, uint256 p1, bool p2) internal pure {
2008
        bytes32 m0;
2009
        bytes32 m1;
2010
        bytes32 m2;
2011
        bytes32 m3;
2012
        /// @solidity memory-safe-assembly
2013
        assembly {
2014
            m0 := mload(0x00)
2015
            m1 := mload(0x20)
2016
            m2 := mload(0x40)
2017
            m3 := mload(0x60)
2018
            // Selector of `log(uint256,uint256,bool)`.
2019
            mstore(0x00, 0x4766da72)
2020
            mstore(0x20, p0)
2021
            mstore(0x40, p1)
2022
            mstore(0x60, p2)
2023
        }
2024
        _sendLogPayload(0x1c, 0x64);
2025
        /// @solidity memory-safe-assembly
2026
        assembly {
2027
            mstore(0x00, m0)
2028
            mstore(0x20, m1)
2029
            mstore(0x40, m2)
2030
            mstore(0x60, m3)
2031
        }
2032
    }
2033

                            
                        
2034
    function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
2035
        bytes32 m0;
2036
        bytes32 m1;
2037
        bytes32 m2;
2038
        bytes32 m3;
2039
        /// @solidity memory-safe-assembly
2040
        assembly {
2041
            m0 := mload(0x00)
2042
            m1 := mload(0x20)
2043
            m2 := mload(0x40)
2044
            m3 := mload(0x60)
2045
            // Selector of `log(uint256,uint256,uint256)`.
2046
            mstore(0x00, 0xd1ed7a3c)
2047
            mstore(0x20, p0)
2048
            mstore(0x40, p1)
2049
            mstore(0x60, p2)
2050
        }
2051
        _sendLogPayload(0x1c, 0x64);
2052
        /// @solidity memory-safe-assembly
2053
        assembly {
2054
            mstore(0x00, m0)
2055
            mstore(0x20, m1)
2056
            mstore(0x40, m2)
2057
            mstore(0x60, m3)
2058
        }
2059
    }
2060

                            
                        
2061
    function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {
2062
        bytes32 m0;
2063
        bytes32 m1;
2064
        bytes32 m2;
2065
        bytes32 m3;
2066
        bytes32 m4;
2067
        bytes32 m5;
2068
        /// @solidity memory-safe-assembly
2069
        assembly {
2070
            function writeString(pos, w) {
2071
                let length := 0
2072
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2073
                mstore(pos, length)
2074
                let shift := sub(256, shl(3, length))
2075
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2076
            }
2077
            m0 := mload(0x00)
2078
            m1 := mload(0x20)
2079
            m2 := mload(0x40)
2080
            m3 := mload(0x60)
2081
            m4 := mload(0x80)
2082
            m5 := mload(0xa0)
2083
            // Selector of `log(uint256,uint256,string)`.
2084
            mstore(0x00, 0x71d04af2)
2085
            mstore(0x20, p0)
2086
            mstore(0x40, p1)
2087
            mstore(0x60, 0x60)
2088
            writeString(0x80, p2)
2089
        }
2090
        _sendLogPayload(0x1c, 0xa4);
2091
        /// @solidity memory-safe-assembly
2092
        assembly {
2093
            mstore(0x00, m0)
2094
            mstore(0x20, m1)
2095
            mstore(0x40, m2)
2096
            mstore(0x60, m3)
2097
            mstore(0x80, m4)
2098
            mstore(0xa0, m5)
2099
        }
2100
    }
2101

                            
                        
2102
    function log(uint256 p0, bytes32 p1, address p2) internal pure {
2103
        bytes32 m0;
2104
        bytes32 m1;
2105
        bytes32 m2;
2106
        bytes32 m3;
2107
        bytes32 m4;
2108
        bytes32 m5;
2109
        /// @solidity memory-safe-assembly
2110
        assembly {
2111
            function writeString(pos, w) {
2112
                let length := 0
2113
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2114
                mstore(pos, length)
2115
                let shift := sub(256, shl(3, length))
2116
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2117
            }
2118
            m0 := mload(0x00)
2119
            m1 := mload(0x20)
2120
            m2 := mload(0x40)
2121
            m3 := mload(0x60)
2122
            m4 := mload(0x80)
2123
            m5 := mload(0xa0)
2124
            // Selector of `log(uint256,string,address)`.
2125
            mstore(0x00, 0x7afac959)
2126
            mstore(0x20, p0)
2127
            mstore(0x40, 0x60)
2128
            mstore(0x60, p2)
2129
            writeString(0x80, p1)
2130
        }
2131
        _sendLogPayload(0x1c, 0xa4);
2132
        /// @solidity memory-safe-assembly
2133
        assembly {
2134
            mstore(0x00, m0)
2135
            mstore(0x20, m1)
2136
            mstore(0x40, m2)
2137
            mstore(0x60, m3)
2138
            mstore(0x80, m4)
2139
            mstore(0xa0, m5)
2140
        }
2141
    }
2142

                            
                        
2143
    function log(uint256 p0, bytes32 p1, bool p2) internal pure {
2144
        bytes32 m0;
2145
        bytes32 m1;
2146
        bytes32 m2;
2147
        bytes32 m3;
2148
        bytes32 m4;
2149
        bytes32 m5;
2150
        /// @solidity memory-safe-assembly
2151
        assembly {
2152
            function writeString(pos, w) {
2153
                let length := 0
2154
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2155
                mstore(pos, length)
2156
                let shift := sub(256, shl(3, length))
2157
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2158
            }
2159
            m0 := mload(0x00)
2160
            m1 := mload(0x20)
2161
            m2 := mload(0x40)
2162
            m3 := mload(0x60)
2163
            m4 := mload(0x80)
2164
            m5 := mload(0xa0)
2165
            // Selector of `log(uint256,string,bool)`.
2166
            mstore(0x00, 0x4ceda75a)
2167
            mstore(0x20, p0)
2168
            mstore(0x40, 0x60)
2169
            mstore(0x60, p2)
2170
            writeString(0x80, p1)
2171
        }
2172
        _sendLogPayload(0x1c, 0xa4);
2173
        /// @solidity memory-safe-assembly
2174
        assembly {
2175
            mstore(0x00, m0)
2176
            mstore(0x20, m1)
2177
            mstore(0x40, m2)
2178
            mstore(0x60, m3)
2179
            mstore(0x80, m4)
2180
            mstore(0xa0, m5)
2181
        }
2182
    }
2183

                            
                        
2184
    function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {
2185
        bytes32 m0;
2186
        bytes32 m1;
2187
        bytes32 m2;
2188
        bytes32 m3;
2189
        bytes32 m4;
2190
        bytes32 m5;
2191
        /// @solidity memory-safe-assembly
2192
        assembly {
2193
            function writeString(pos, w) {
2194
                let length := 0
2195
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2196
                mstore(pos, length)
2197
                let shift := sub(256, shl(3, length))
2198
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2199
            }
2200
            m0 := mload(0x00)
2201
            m1 := mload(0x20)
2202
            m2 := mload(0x40)
2203
            m3 := mload(0x60)
2204
            m4 := mload(0x80)
2205
            m5 := mload(0xa0)
2206
            // Selector of `log(uint256,string,uint256)`.
2207
            mstore(0x00, 0x37aa7d4c)
2208
            mstore(0x20, p0)
2209
            mstore(0x40, 0x60)
2210
            mstore(0x60, p2)
2211
            writeString(0x80, p1)
2212
        }
2213
        _sendLogPayload(0x1c, 0xa4);
2214
        /// @solidity memory-safe-assembly
2215
        assembly {
2216
            mstore(0x00, m0)
2217
            mstore(0x20, m1)
2218
            mstore(0x40, m2)
2219
            mstore(0x60, m3)
2220
            mstore(0x80, m4)
2221
            mstore(0xa0, m5)
2222
        }
2223
    }
2224

                            
                        
2225
    function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {
2226
        bytes32 m0;
2227
        bytes32 m1;
2228
        bytes32 m2;
2229
        bytes32 m3;
2230
        bytes32 m4;
2231
        bytes32 m5;
2232
        bytes32 m6;
2233
        bytes32 m7;
2234
        /// @solidity memory-safe-assembly
2235
        assembly {
2236
            function writeString(pos, w) {
2237
                let length := 0
2238
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2239
                mstore(pos, length)
2240
                let shift := sub(256, shl(3, length))
2241
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2242
            }
2243
            m0 := mload(0x00)
2244
            m1 := mload(0x20)
2245
            m2 := mload(0x40)
2246
            m3 := mload(0x60)
2247
            m4 := mload(0x80)
2248
            m5 := mload(0xa0)
2249
            m6 := mload(0xc0)
2250
            m7 := mload(0xe0)
2251
            // Selector of `log(uint256,string,string)`.
2252
            mstore(0x00, 0xb115611f)
2253
            mstore(0x20, p0)
2254
            mstore(0x40, 0x60)
2255
            mstore(0x60, 0xa0)
2256
            writeString(0x80, p1)
2257
            writeString(0xc0, p2)
2258
        }
2259
        _sendLogPayload(0x1c, 0xe4);
2260
        /// @solidity memory-safe-assembly
2261
        assembly {
2262
            mstore(0x00, m0)
2263
            mstore(0x20, m1)
2264
            mstore(0x40, m2)
2265
            mstore(0x60, m3)
2266
            mstore(0x80, m4)
2267
            mstore(0xa0, m5)
2268
            mstore(0xc0, m6)
2269
            mstore(0xe0, m7)
2270
        }
2271
    }
2272

                            
                        
2273
    function log(bytes32 p0, address p1, address p2) internal pure {
2274
        bytes32 m0;
2275
        bytes32 m1;
2276
        bytes32 m2;
2277
        bytes32 m3;
2278
        bytes32 m4;
2279
        bytes32 m5;
2280
        /// @solidity memory-safe-assembly
2281
        assembly {
2282
            function writeString(pos, w) {
2283
                let length := 0
2284
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2285
                mstore(pos, length)
2286
                let shift := sub(256, shl(3, length))
2287
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2288
            }
2289
            m0 := mload(0x00)
2290
            m1 := mload(0x20)
2291
            m2 := mload(0x40)
2292
            m3 := mload(0x60)
2293
            m4 := mload(0x80)
2294
            m5 := mload(0xa0)
2295
            // Selector of `log(string,address,address)`.
2296
            mstore(0x00, 0xfcec75e0)
2297
            mstore(0x20, 0x60)
2298
            mstore(0x40, p1)
2299
            mstore(0x60, p2)
2300
            writeString(0x80, p0)
2301
        }
2302
        _sendLogPayload(0x1c, 0xa4);
2303
        /// @solidity memory-safe-assembly
2304
        assembly {
2305
            mstore(0x00, m0)
2306
            mstore(0x20, m1)
2307
            mstore(0x40, m2)
2308
            mstore(0x60, m3)
2309
            mstore(0x80, m4)
2310
            mstore(0xa0, m5)
2311
        }
2312
    }
2313

                            
                        
2314
    function log(bytes32 p0, address p1, bool p2) internal pure {
2315
        bytes32 m0;
2316
        bytes32 m1;
2317
        bytes32 m2;
2318
        bytes32 m3;
2319
        bytes32 m4;
2320
        bytes32 m5;
2321
        /// @solidity memory-safe-assembly
2322
        assembly {
2323
            function writeString(pos, w) {
2324
                let length := 0
2325
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2326
                mstore(pos, length)
2327
                let shift := sub(256, shl(3, length))
2328
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2329
            }
2330
            m0 := mload(0x00)
2331
            m1 := mload(0x20)
2332
            m2 := mload(0x40)
2333
            m3 := mload(0x60)
2334
            m4 := mload(0x80)
2335
            m5 := mload(0xa0)
2336
            // Selector of `log(string,address,bool)`.
2337
            mstore(0x00, 0xc91d5ed4)
2338
            mstore(0x20, 0x60)
2339
            mstore(0x40, p1)
2340
            mstore(0x60, p2)
2341
            writeString(0x80, p0)
2342
        }
2343
        _sendLogPayload(0x1c, 0xa4);
2344
        /// @solidity memory-safe-assembly
2345
        assembly {
2346
            mstore(0x00, m0)
2347
            mstore(0x20, m1)
2348
            mstore(0x40, m2)
2349
            mstore(0x60, m3)
2350
            mstore(0x80, m4)
2351
            mstore(0xa0, m5)
2352
        }
2353
    }
2354

                            
                        
2355
    function log(bytes32 p0, address p1, uint256 p2) internal pure {
2356
        bytes32 m0;
2357
        bytes32 m1;
2358
        bytes32 m2;
2359
        bytes32 m3;
2360
        bytes32 m4;
2361
        bytes32 m5;
2362
        /// @solidity memory-safe-assembly
2363
        assembly {
2364
            function writeString(pos, w) {
2365
                let length := 0
2366
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2367
                mstore(pos, length)
2368
                let shift := sub(256, shl(3, length))
2369
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2370
            }
2371
            m0 := mload(0x00)
2372
            m1 := mload(0x20)
2373
            m2 := mload(0x40)
2374
            m3 := mload(0x60)
2375
            m4 := mload(0x80)
2376
            m5 := mload(0xa0)
2377
            // Selector of `log(string,address,uint256)`.
2378
            mstore(0x00, 0x0d26b925)
2379
            mstore(0x20, 0x60)
2380
            mstore(0x40, p1)
2381
            mstore(0x60, p2)
2382
            writeString(0x80, p0)
2383
        }
2384
        _sendLogPayload(0x1c, 0xa4);
2385
        /// @solidity memory-safe-assembly
2386
        assembly {
2387
            mstore(0x00, m0)
2388
            mstore(0x20, m1)
2389
            mstore(0x40, m2)
2390
            mstore(0x60, m3)
2391
            mstore(0x80, m4)
2392
            mstore(0xa0, m5)
2393
        }
2394
    }
2395

                            
                        
2396
    function log(bytes32 p0, address p1, bytes32 p2) internal pure {
2397
        bytes32 m0;
2398
        bytes32 m1;
2399
        bytes32 m2;
2400
        bytes32 m3;
2401
        bytes32 m4;
2402
        bytes32 m5;
2403
        bytes32 m6;
2404
        bytes32 m7;
2405
        /// @solidity memory-safe-assembly
2406
        assembly {
2407
            function writeString(pos, w) {
2408
                let length := 0
2409
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2410
                mstore(pos, length)
2411
                let shift := sub(256, shl(3, length))
2412
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2413
            }
2414
            m0 := mload(0x00)
2415
            m1 := mload(0x20)
2416
            m2 := mload(0x40)
2417
            m3 := mload(0x60)
2418
            m4 := mload(0x80)
2419
            m5 := mload(0xa0)
2420
            m6 := mload(0xc0)
2421
            m7 := mload(0xe0)
2422
            // Selector of `log(string,address,string)`.
2423
            mstore(0x00, 0xe0e9ad4f)
2424
            mstore(0x20, 0x60)
2425
            mstore(0x40, p1)
2426
            mstore(0x60, 0xa0)
2427
            writeString(0x80, p0)
2428
            writeString(0xc0, p2)
2429
        }
2430
        _sendLogPayload(0x1c, 0xe4);
2431
        /// @solidity memory-safe-assembly
2432
        assembly {
2433
            mstore(0x00, m0)
2434
            mstore(0x20, m1)
2435
            mstore(0x40, m2)
2436
            mstore(0x60, m3)
2437
            mstore(0x80, m4)
2438
            mstore(0xa0, m5)
2439
            mstore(0xc0, m6)
2440
            mstore(0xe0, m7)
2441
        }
2442
    }
2443

                            
                        
2444
    function log(bytes32 p0, bool p1, address p2) internal pure {
2445
        bytes32 m0;
2446
        bytes32 m1;
2447
        bytes32 m2;
2448
        bytes32 m3;
2449
        bytes32 m4;
2450
        bytes32 m5;
2451
        /// @solidity memory-safe-assembly
2452
        assembly {
2453
            function writeString(pos, w) {
2454
                let length := 0
2455
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2456
                mstore(pos, length)
2457
                let shift := sub(256, shl(3, length))
2458
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2459
            }
2460
            m0 := mload(0x00)
2461
            m1 := mload(0x20)
2462
            m2 := mload(0x40)
2463
            m3 := mload(0x60)
2464
            m4 := mload(0x80)
2465
            m5 := mload(0xa0)
2466
            // Selector of `log(string,bool,address)`.
2467
            mstore(0x00, 0x932bbb38)
2468
            mstore(0x20, 0x60)
2469
            mstore(0x40, p1)
2470
            mstore(0x60, p2)
2471
            writeString(0x80, p0)
2472
        }
2473
        _sendLogPayload(0x1c, 0xa4);
2474
        /// @solidity memory-safe-assembly
2475
        assembly {
2476
            mstore(0x00, m0)
2477
            mstore(0x20, m1)
2478
            mstore(0x40, m2)
2479
            mstore(0x60, m3)
2480
            mstore(0x80, m4)
2481
            mstore(0xa0, m5)
2482
        }
2483
    }
2484

                            
                        
2485
    function log(bytes32 p0, bool p1, bool p2) internal pure {
2486
        bytes32 m0;
2487
        bytes32 m1;
2488
        bytes32 m2;
2489
        bytes32 m3;
2490
        bytes32 m4;
2491
        bytes32 m5;
2492
        /// @solidity memory-safe-assembly
2493
        assembly {
2494
            function writeString(pos, w) {
2495
                let length := 0
2496
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2497
                mstore(pos, length)
2498
                let shift := sub(256, shl(3, length))
2499
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2500
            }
2501
            m0 := mload(0x00)
2502
            m1 := mload(0x20)
2503
            m2 := mload(0x40)
2504
            m3 := mload(0x60)
2505
            m4 := mload(0x80)
2506
            m5 := mload(0xa0)
2507
            // Selector of `log(string,bool,bool)`.
2508
            mstore(0x00, 0x850b7ad6)
2509
            mstore(0x20, 0x60)
2510
            mstore(0x40, p1)
2511
            mstore(0x60, p2)
2512
            writeString(0x80, p0)
2513
        }
2514
        _sendLogPayload(0x1c, 0xa4);
2515
        /// @solidity memory-safe-assembly
2516
        assembly {
2517
            mstore(0x00, m0)
2518
            mstore(0x20, m1)
2519
            mstore(0x40, m2)
2520
            mstore(0x60, m3)
2521
            mstore(0x80, m4)
2522
            mstore(0xa0, m5)
2523
        }
2524
    }
2525

                            
                        
2526
    function log(bytes32 p0, bool p1, uint256 p2) internal pure {
2527
        bytes32 m0;
2528
        bytes32 m1;
2529
        bytes32 m2;
2530
        bytes32 m3;
2531
        bytes32 m4;
2532
        bytes32 m5;
2533
        /// @solidity memory-safe-assembly
2534
        assembly {
2535
            function writeString(pos, w) {
2536
                let length := 0
2537
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2538
                mstore(pos, length)
2539
                let shift := sub(256, shl(3, length))
2540
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2541
            }
2542
            m0 := mload(0x00)
2543
            m1 := mload(0x20)
2544
            m2 := mload(0x40)
2545
            m3 := mload(0x60)
2546
            m4 := mload(0x80)
2547
            m5 := mload(0xa0)
2548
            // Selector of `log(string,bool,uint256)`.
2549
            mstore(0x00, 0xc95958d6)
2550
            mstore(0x20, 0x60)
2551
            mstore(0x40, p1)
2552
            mstore(0x60, p2)
2553
            writeString(0x80, p0)
2554
        }
2555
        _sendLogPayload(0x1c, 0xa4);
2556
        /// @solidity memory-safe-assembly
2557
        assembly {
2558
            mstore(0x00, m0)
2559
            mstore(0x20, m1)
2560
            mstore(0x40, m2)
2561
            mstore(0x60, m3)
2562
            mstore(0x80, m4)
2563
            mstore(0xa0, m5)
2564
        }
2565
    }
2566

                            
                        
2567
    function log(bytes32 p0, bool p1, bytes32 p2) internal pure {
2568
        bytes32 m0;
2569
        bytes32 m1;
2570
        bytes32 m2;
2571
        bytes32 m3;
2572
        bytes32 m4;
2573
        bytes32 m5;
2574
        bytes32 m6;
2575
        bytes32 m7;
2576
        /// @solidity memory-safe-assembly
2577
        assembly {
2578
            function writeString(pos, w) {
2579
                let length := 0
2580
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2581
                mstore(pos, length)
2582
                let shift := sub(256, shl(3, length))
2583
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2584
            }
2585
            m0 := mload(0x00)
2586
            m1 := mload(0x20)
2587
            m2 := mload(0x40)
2588
            m3 := mload(0x60)
2589
            m4 := mload(0x80)
2590
            m5 := mload(0xa0)
2591
            m6 := mload(0xc0)
2592
            m7 := mload(0xe0)
2593
            // Selector of `log(string,bool,string)`.
2594
            mstore(0x00, 0xe298f47d)
2595
            mstore(0x20, 0x60)
2596
            mstore(0x40, p1)
2597
            mstore(0x60, 0xa0)
2598
            writeString(0x80, p0)
2599
            writeString(0xc0, p2)
2600
        }
2601
        _sendLogPayload(0x1c, 0xe4);
2602
        /// @solidity memory-safe-assembly
2603
        assembly {
2604
            mstore(0x00, m0)
2605
            mstore(0x20, m1)
2606
            mstore(0x40, m2)
2607
            mstore(0x60, m3)
2608
            mstore(0x80, m4)
2609
            mstore(0xa0, m5)
2610
            mstore(0xc0, m6)
2611
            mstore(0xe0, m7)
2612
        }
2613
    }
2614

                            
                        
2615
    function log(bytes32 p0, uint256 p1, address p2) internal pure {
2616
        bytes32 m0;
2617
        bytes32 m1;
2618
        bytes32 m2;
2619
        bytes32 m3;
2620
        bytes32 m4;
2621
        bytes32 m5;
2622
        /// @solidity memory-safe-assembly
2623
        assembly {
2624
            function writeString(pos, w) {
2625
                let length := 0
2626
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2627
                mstore(pos, length)
2628
                let shift := sub(256, shl(3, length))
2629
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2630
            }
2631
            m0 := mload(0x00)
2632
            m1 := mload(0x20)
2633
            m2 := mload(0x40)
2634
            m3 := mload(0x60)
2635
            m4 := mload(0x80)
2636
            m5 := mload(0xa0)
2637
            // Selector of `log(string,uint256,address)`.
2638
            mstore(0x00, 0x1c7ec448)
2639
            mstore(0x20, 0x60)
2640
            mstore(0x40, p1)
2641
            mstore(0x60, p2)
2642
            writeString(0x80, p0)
2643
        }
2644
        _sendLogPayload(0x1c, 0xa4);
2645
        /// @solidity memory-safe-assembly
2646
        assembly {
2647
            mstore(0x00, m0)
2648
            mstore(0x20, m1)
2649
            mstore(0x40, m2)
2650
            mstore(0x60, m3)
2651
            mstore(0x80, m4)
2652
            mstore(0xa0, m5)
2653
        }
2654
    }
2655

                            
                        
2656
    function log(bytes32 p0, uint256 p1, bool p2) internal pure {
2657
        bytes32 m0;
2658
        bytes32 m1;
2659
        bytes32 m2;
2660
        bytes32 m3;
2661
        bytes32 m4;
2662
        bytes32 m5;
2663
        /// @solidity memory-safe-assembly
2664
        assembly {
2665
            function writeString(pos, w) {
2666
                let length := 0
2667
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2668
                mstore(pos, length)
2669
                let shift := sub(256, shl(3, length))
2670
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2671
            }
2672
            m0 := mload(0x00)
2673
            m1 := mload(0x20)
2674
            m2 := mload(0x40)
2675
            m3 := mload(0x60)
2676
            m4 := mload(0x80)
2677
            m5 := mload(0xa0)
2678
            // Selector of `log(string,uint256,bool)`.
2679
            mstore(0x00, 0xca7733b1)
2680
            mstore(0x20, 0x60)
2681
            mstore(0x40, p1)
2682
            mstore(0x60, p2)
2683
            writeString(0x80, p0)
2684
        }
2685
        _sendLogPayload(0x1c, 0xa4);
2686
        /// @solidity memory-safe-assembly
2687
        assembly {
2688
            mstore(0x00, m0)
2689
            mstore(0x20, m1)
2690
            mstore(0x40, m2)
2691
            mstore(0x60, m3)
2692
            mstore(0x80, m4)
2693
            mstore(0xa0, m5)
2694
        }
2695
    }
2696

                            
                        
2697
    function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {
2698
        bytes32 m0;
2699
        bytes32 m1;
2700
        bytes32 m2;
2701
        bytes32 m3;
2702
        bytes32 m4;
2703
        bytes32 m5;
2704
        /// @solidity memory-safe-assembly
2705
        assembly {
2706
            function writeString(pos, w) {
2707
                let length := 0
2708
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2709
                mstore(pos, length)
2710
                let shift := sub(256, shl(3, length))
2711
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2712
            }
2713
            m0 := mload(0x00)
2714
            m1 := mload(0x20)
2715
            m2 := mload(0x40)
2716
            m3 := mload(0x60)
2717
            m4 := mload(0x80)
2718
            m5 := mload(0xa0)
2719
            // Selector of `log(string,uint256,uint256)`.
2720
            mstore(0x00, 0xca47c4eb)
2721
            mstore(0x20, 0x60)
2722
            mstore(0x40, p1)
2723
            mstore(0x60, p2)
2724
            writeString(0x80, p0)
2725
        }
2726
        _sendLogPayload(0x1c, 0xa4);
2727
        /// @solidity memory-safe-assembly
2728
        assembly {
2729
            mstore(0x00, m0)
2730
            mstore(0x20, m1)
2731
            mstore(0x40, m2)
2732
            mstore(0x60, m3)
2733
            mstore(0x80, m4)
2734
            mstore(0xa0, m5)
2735
        }
2736
    }
2737

                            
                        
2738
    function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {
2739
        bytes32 m0;
2740
        bytes32 m1;
2741
        bytes32 m2;
2742
        bytes32 m3;
2743
        bytes32 m4;
2744
        bytes32 m5;
2745
        bytes32 m6;
2746
        bytes32 m7;
2747
        /// @solidity memory-safe-assembly
2748
        assembly {
2749
            function writeString(pos, w) {
2750
                let length := 0
2751
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2752
                mstore(pos, length)
2753
                let shift := sub(256, shl(3, length))
2754
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2755
            }
2756
            m0 := mload(0x00)
2757
            m1 := mload(0x20)
2758
            m2 := mload(0x40)
2759
            m3 := mload(0x60)
2760
            m4 := mload(0x80)
2761
            m5 := mload(0xa0)
2762
            m6 := mload(0xc0)
2763
            m7 := mload(0xe0)
2764
            // Selector of `log(string,uint256,string)`.
2765
            mstore(0x00, 0x5970e089)
2766
            mstore(0x20, 0x60)
2767
            mstore(0x40, p1)
2768
            mstore(0x60, 0xa0)
2769
            writeString(0x80, p0)
2770
            writeString(0xc0, p2)
2771
        }
2772
        _sendLogPayload(0x1c, 0xe4);
2773
        /// @solidity memory-safe-assembly
2774
        assembly {
2775
            mstore(0x00, m0)
2776
            mstore(0x20, m1)
2777
            mstore(0x40, m2)
2778
            mstore(0x60, m3)
2779
            mstore(0x80, m4)
2780
            mstore(0xa0, m5)
2781
            mstore(0xc0, m6)
2782
            mstore(0xe0, m7)
2783
        }
2784
    }
2785

                            
                        
2786
    function log(bytes32 p0, bytes32 p1, address p2) internal pure {
2787
        bytes32 m0;
2788
        bytes32 m1;
2789
        bytes32 m2;
2790
        bytes32 m3;
2791
        bytes32 m4;
2792
        bytes32 m5;
2793
        bytes32 m6;
2794
        bytes32 m7;
2795
        /// @solidity memory-safe-assembly
2796
        assembly {
2797
            function writeString(pos, w) {
2798
                let length := 0
2799
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2800
                mstore(pos, length)
2801
                let shift := sub(256, shl(3, length))
2802
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2803
            }
2804
            m0 := mload(0x00)
2805
            m1 := mload(0x20)
2806
            m2 := mload(0x40)
2807
            m3 := mload(0x60)
2808
            m4 := mload(0x80)
2809
            m5 := mload(0xa0)
2810
            m6 := mload(0xc0)
2811
            m7 := mload(0xe0)
2812
            // Selector of `log(string,string,address)`.
2813
            mstore(0x00, 0x95ed0195)
2814
            mstore(0x20, 0x60)
2815
            mstore(0x40, 0xa0)
2816
            mstore(0x60, p2)
2817
            writeString(0x80, p0)
2818
            writeString(0xc0, p1)
2819
        }
2820
        _sendLogPayload(0x1c, 0xe4);
2821
        /// @solidity memory-safe-assembly
2822
        assembly {
2823
            mstore(0x00, m0)
2824
            mstore(0x20, m1)
2825
            mstore(0x40, m2)
2826
            mstore(0x60, m3)
2827
            mstore(0x80, m4)
2828
            mstore(0xa0, m5)
2829
            mstore(0xc0, m6)
2830
            mstore(0xe0, m7)
2831
        }
2832
    }
2833

                            
                        
2834
    function log(bytes32 p0, bytes32 p1, bool p2) internal pure {
2835
        bytes32 m0;
2836
        bytes32 m1;
2837
        bytes32 m2;
2838
        bytes32 m3;
2839
        bytes32 m4;
2840
        bytes32 m5;
2841
        bytes32 m6;
2842
        bytes32 m7;
2843
        /// @solidity memory-safe-assembly
2844
        assembly {
2845
            function writeString(pos, w) {
2846
                let length := 0
2847
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2848
                mstore(pos, length)
2849
                let shift := sub(256, shl(3, length))
2850
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2851
            }
2852
            m0 := mload(0x00)
2853
            m1 := mload(0x20)
2854
            m2 := mload(0x40)
2855
            m3 := mload(0x60)
2856
            m4 := mload(0x80)
2857
            m5 := mload(0xa0)
2858
            m6 := mload(0xc0)
2859
            m7 := mload(0xe0)
2860
            // Selector of `log(string,string,bool)`.
2861
            mstore(0x00, 0xb0e0f9b5)
2862
            mstore(0x20, 0x60)
2863
            mstore(0x40, 0xa0)
2864
            mstore(0x60, p2)
2865
            writeString(0x80, p0)
2866
            writeString(0xc0, p1)
2867
        }
2868
        _sendLogPayload(0x1c, 0xe4);
2869
        /// @solidity memory-safe-assembly
2870
        assembly {
2871
            mstore(0x00, m0)
2872
            mstore(0x20, m1)
2873
            mstore(0x40, m2)
2874
            mstore(0x60, m3)
2875
            mstore(0x80, m4)
2876
            mstore(0xa0, m5)
2877
            mstore(0xc0, m6)
2878
            mstore(0xe0, m7)
2879
        }
2880
    }
2881

                            
                        
2882
    function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {
2883
        bytes32 m0;
2884
        bytes32 m1;
2885
        bytes32 m2;
2886
        bytes32 m3;
2887
        bytes32 m4;
2888
        bytes32 m5;
2889
        bytes32 m6;
2890
        bytes32 m7;
2891
        /// @solidity memory-safe-assembly
2892
        assembly {
2893
            function writeString(pos, w) {
2894
                let length := 0
2895
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2896
                mstore(pos, length)
2897
                let shift := sub(256, shl(3, length))
2898
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2899
            }
2900
            m0 := mload(0x00)
2901
            m1 := mload(0x20)
2902
            m2 := mload(0x40)
2903
            m3 := mload(0x60)
2904
            m4 := mload(0x80)
2905
            m5 := mload(0xa0)
2906
            m6 := mload(0xc0)
2907
            m7 := mload(0xe0)
2908
            // Selector of `log(string,string,uint256)`.
2909
            mstore(0x00, 0x5821efa1)
2910
            mstore(0x20, 0x60)
2911
            mstore(0x40, 0xa0)
2912
            mstore(0x60, p2)
2913
            writeString(0x80, p0)
2914
            writeString(0xc0, p1)
2915
        }
2916
        _sendLogPayload(0x1c, 0xe4);
2917
        /// @solidity memory-safe-assembly
2918
        assembly {
2919
            mstore(0x00, m0)
2920
            mstore(0x20, m1)
2921
            mstore(0x40, m2)
2922
            mstore(0x60, m3)
2923
            mstore(0x80, m4)
2924
            mstore(0xa0, m5)
2925
            mstore(0xc0, m6)
2926
            mstore(0xe0, m7)
2927
        }
2928
    }
2929

                            
                        
2930
    function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {
2931
        bytes32 m0;
2932
        bytes32 m1;
2933
        bytes32 m2;
2934
        bytes32 m3;
2935
        bytes32 m4;
2936
        bytes32 m5;
2937
        bytes32 m6;
2938
        bytes32 m7;
2939
        bytes32 m8;
2940
        bytes32 m9;
2941
        /// @solidity memory-safe-assembly
2942
        assembly {
2943
            function writeString(pos, w) {
2944
                let length := 0
2945
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
2946
                mstore(pos, length)
2947
                let shift := sub(256, shl(3, length))
2948
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
2949
            }
2950
            m0 := mload(0x00)
2951
            m1 := mload(0x20)
2952
            m2 := mload(0x40)
2953
            m3 := mload(0x60)
2954
            m4 := mload(0x80)
2955
            m5 := mload(0xa0)
2956
            m6 := mload(0xc0)
2957
            m7 := mload(0xe0)
2958
            m8 := mload(0x100)
2959
            m9 := mload(0x120)
2960
            // Selector of `log(string,string,string)`.
2961
            mstore(0x00, 0x2ced7cef)
2962
            mstore(0x20, 0x60)
2963
            mstore(0x40, 0xa0)
2964
            mstore(0x60, 0xe0)
2965
            writeString(0x80, p0)
2966
            writeString(0xc0, p1)
2967
            writeString(0x100, p2)
2968
        }
2969
        _sendLogPayload(0x1c, 0x124);
2970
        /// @solidity memory-safe-assembly
2971
        assembly {
2972
            mstore(0x00, m0)
2973
            mstore(0x20, m1)
2974
            mstore(0x40, m2)
2975
            mstore(0x60, m3)
2976
            mstore(0x80, m4)
2977
            mstore(0xa0, m5)
2978
            mstore(0xc0, m6)
2979
            mstore(0xe0, m7)
2980
            mstore(0x100, m8)
2981
            mstore(0x120, m9)
2982
        }
2983
    }
2984

                            
                        
2985
    function log(address p0, address p1, address p2, address p3) internal pure {
2986
        bytes32 m0;
2987
        bytes32 m1;
2988
        bytes32 m2;
2989
        bytes32 m3;
2990
        bytes32 m4;
2991
        /// @solidity memory-safe-assembly
2992
        assembly {
2993
            m0 := mload(0x00)
2994
            m1 := mload(0x20)
2995
            m2 := mload(0x40)
2996
            m3 := mload(0x60)
2997
            m4 := mload(0x80)
2998
            // Selector of `log(address,address,address,address)`.
2999
            mstore(0x00, 0x665bf134)
3000
            mstore(0x20, p0)
3001
            mstore(0x40, p1)
3002
            mstore(0x60, p2)
3003
            mstore(0x80, p3)
3004
        }
3005
        _sendLogPayload(0x1c, 0x84);
3006
        /// @solidity memory-safe-assembly
3007
        assembly {
3008
            mstore(0x00, m0)
3009
            mstore(0x20, m1)
3010
            mstore(0x40, m2)
3011
            mstore(0x60, m3)
3012
            mstore(0x80, m4)
3013
        }
3014
    }
3015

                            
                        
3016
    function log(address p0, address p1, address p2, bool p3) internal pure {
3017
        bytes32 m0;
3018
        bytes32 m1;
3019
        bytes32 m2;
3020
        bytes32 m3;
3021
        bytes32 m4;
3022
        /// @solidity memory-safe-assembly
3023
        assembly {
3024
            m0 := mload(0x00)
3025
            m1 := mload(0x20)
3026
            m2 := mload(0x40)
3027
            m3 := mload(0x60)
3028
            m4 := mload(0x80)
3029
            // Selector of `log(address,address,address,bool)`.
3030
            mstore(0x00, 0x0e378994)
3031
            mstore(0x20, p0)
3032
            mstore(0x40, p1)
3033
            mstore(0x60, p2)
3034
            mstore(0x80, p3)
3035
        }
3036
        _sendLogPayload(0x1c, 0x84);
3037
        /// @solidity memory-safe-assembly
3038
        assembly {
3039
            mstore(0x00, m0)
3040
            mstore(0x20, m1)
3041
            mstore(0x40, m2)
3042
            mstore(0x60, m3)
3043
            mstore(0x80, m4)
3044
        }
3045
    }
3046

                            
                        
3047
    function log(address p0, address p1, address p2, uint256 p3) internal pure {
3048
        bytes32 m0;
3049
        bytes32 m1;
3050
        bytes32 m2;
3051
        bytes32 m3;
3052
        bytes32 m4;
3053
        /// @solidity memory-safe-assembly
3054
        assembly {
3055
            m0 := mload(0x00)
3056
            m1 := mload(0x20)
3057
            m2 := mload(0x40)
3058
            m3 := mload(0x60)
3059
            m4 := mload(0x80)
3060
            // Selector of `log(address,address,address,uint256)`.
3061
            mstore(0x00, 0x94250d77)
3062
            mstore(0x20, p0)
3063
            mstore(0x40, p1)
3064
            mstore(0x60, p2)
3065
            mstore(0x80, p3)
3066
        }
3067
        _sendLogPayload(0x1c, 0x84);
3068
        /// @solidity memory-safe-assembly
3069
        assembly {
3070
            mstore(0x00, m0)
3071
            mstore(0x20, m1)
3072
            mstore(0x40, m2)
3073
            mstore(0x60, m3)
3074
            mstore(0x80, m4)
3075
        }
3076
    }
3077

                            
                        
3078
    function log(address p0, address p1, address p2, bytes32 p3) internal pure {
3079
        bytes32 m0;
3080
        bytes32 m1;
3081
        bytes32 m2;
3082
        bytes32 m3;
3083
        bytes32 m4;
3084
        bytes32 m5;
3085
        bytes32 m6;
3086
        /// @solidity memory-safe-assembly
3087
        assembly {
3088
            function writeString(pos, w) {
3089
                let length := 0
3090
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3091
                mstore(pos, length)
3092
                let shift := sub(256, shl(3, length))
3093
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3094
            }
3095
            m0 := mload(0x00)
3096
            m1 := mload(0x20)
3097
            m2 := mload(0x40)
3098
            m3 := mload(0x60)
3099
            m4 := mload(0x80)
3100
            m5 := mload(0xa0)
3101
            m6 := mload(0xc0)
3102
            // Selector of `log(address,address,address,string)`.
3103
            mstore(0x00, 0xf808da20)
3104
            mstore(0x20, p0)
3105
            mstore(0x40, p1)
3106
            mstore(0x60, p2)
3107
            mstore(0x80, 0x80)
3108
            writeString(0xa0, p3)
3109
        }
3110
        _sendLogPayload(0x1c, 0xc4);
3111
        /// @solidity memory-safe-assembly
3112
        assembly {
3113
            mstore(0x00, m0)
3114
            mstore(0x20, m1)
3115
            mstore(0x40, m2)
3116
            mstore(0x60, m3)
3117
            mstore(0x80, m4)
3118
            mstore(0xa0, m5)
3119
            mstore(0xc0, m6)
3120
        }
3121
    }
3122

                            
                        
3123
    function log(address p0, address p1, bool p2, address p3) internal pure {
3124
        bytes32 m0;
3125
        bytes32 m1;
3126
        bytes32 m2;
3127
        bytes32 m3;
3128
        bytes32 m4;
3129
        /// @solidity memory-safe-assembly
3130
        assembly {
3131
            m0 := mload(0x00)
3132
            m1 := mload(0x20)
3133
            m2 := mload(0x40)
3134
            m3 := mload(0x60)
3135
            m4 := mload(0x80)
3136
            // Selector of `log(address,address,bool,address)`.
3137
            mstore(0x00, 0x9f1bc36e)
3138
            mstore(0x20, p0)
3139
            mstore(0x40, p1)
3140
            mstore(0x60, p2)
3141
            mstore(0x80, p3)
3142
        }
3143
        _sendLogPayload(0x1c, 0x84);
3144
        /// @solidity memory-safe-assembly
3145
        assembly {
3146
            mstore(0x00, m0)
3147
            mstore(0x20, m1)
3148
            mstore(0x40, m2)
3149
            mstore(0x60, m3)
3150
            mstore(0x80, m4)
3151
        }
3152
    }
3153

                            
                        
3154
    function log(address p0, address p1, bool p2, bool p3) internal pure {
3155
        bytes32 m0;
3156
        bytes32 m1;
3157
        bytes32 m2;
3158
        bytes32 m3;
3159
        bytes32 m4;
3160
        /// @solidity memory-safe-assembly
3161
        assembly {
3162
            m0 := mload(0x00)
3163
            m1 := mload(0x20)
3164
            m2 := mload(0x40)
3165
            m3 := mload(0x60)
3166
            m4 := mload(0x80)
3167
            // Selector of `log(address,address,bool,bool)`.
3168
            mstore(0x00, 0x2cd4134a)
3169
            mstore(0x20, p0)
3170
            mstore(0x40, p1)
3171
            mstore(0x60, p2)
3172
            mstore(0x80, p3)
3173
        }
3174
        _sendLogPayload(0x1c, 0x84);
3175
        /// @solidity memory-safe-assembly
3176
        assembly {
3177
            mstore(0x00, m0)
3178
            mstore(0x20, m1)
3179
            mstore(0x40, m2)
3180
            mstore(0x60, m3)
3181
            mstore(0x80, m4)
3182
        }
3183
    }
3184

                            
                        
3185
    function log(address p0, address p1, bool p2, uint256 p3) internal pure {
3186
        bytes32 m0;
3187
        bytes32 m1;
3188
        bytes32 m2;
3189
        bytes32 m3;
3190
        bytes32 m4;
3191
        /// @solidity memory-safe-assembly
3192
        assembly {
3193
            m0 := mload(0x00)
3194
            m1 := mload(0x20)
3195
            m2 := mload(0x40)
3196
            m3 := mload(0x60)
3197
            m4 := mload(0x80)
3198
            // Selector of `log(address,address,bool,uint256)`.
3199
            mstore(0x00, 0x3971e78c)
3200
            mstore(0x20, p0)
3201
            mstore(0x40, p1)
3202
            mstore(0x60, p2)
3203
            mstore(0x80, p3)
3204
        }
3205
        _sendLogPayload(0x1c, 0x84);
3206
        /// @solidity memory-safe-assembly
3207
        assembly {
3208
            mstore(0x00, m0)
3209
            mstore(0x20, m1)
3210
            mstore(0x40, m2)
3211
            mstore(0x60, m3)
3212
            mstore(0x80, m4)
3213
        }
3214
    }
3215

                            
                        
3216
    function log(address p0, address p1, bool p2, bytes32 p3) internal pure {
3217
        bytes32 m0;
3218
        bytes32 m1;
3219
        bytes32 m2;
3220
        bytes32 m3;
3221
        bytes32 m4;
3222
        bytes32 m5;
3223
        bytes32 m6;
3224
        /// @solidity memory-safe-assembly
3225
        assembly {
3226
            function writeString(pos, w) {
3227
                let length := 0
3228
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3229
                mstore(pos, length)
3230
                let shift := sub(256, shl(3, length))
3231
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3232
            }
3233
            m0 := mload(0x00)
3234
            m1 := mload(0x20)
3235
            m2 := mload(0x40)
3236
            m3 := mload(0x60)
3237
            m4 := mload(0x80)
3238
            m5 := mload(0xa0)
3239
            m6 := mload(0xc0)
3240
            // Selector of `log(address,address,bool,string)`.
3241
            mstore(0x00, 0xaa6540c8)
3242
            mstore(0x20, p0)
3243
            mstore(0x40, p1)
3244
            mstore(0x60, p2)
3245
            mstore(0x80, 0x80)
3246
            writeString(0xa0, p3)
3247
        }
3248
        _sendLogPayload(0x1c, 0xc4);
3249
        /// @solidity memory-safe-assembly
3250
        assembly {
3251
            mstore(0x00, m0)
3252
            mstore(0x20, m1)
3253
            mstore(0x40, m2)
3254
            mstore(0x60, m3)
3255
            mstore(0x80, m4)
3256
            mstore(0xa0, m5)
3257
            mstore(0xc0, m6)
3258
        }
3259
    }
3260

                            
                        
3261
    function log(address p0, address p1, uint256 p2, address p3) internal pure {
3262
        bytes32 m0;
3263
        bytes32 m1;
3264
        bytes32 m2;
3265
        bytes32 m3;
3266
        bytes32 m4;
3267
        /// @solidity memory-safe-assembly
3268
        assembly {
3269
            m0 := mload(0x00)
3270
            m1 := mload(0x20)
3271
            m2 := mload(0x40)
3272
            m3 := mload(0x60)
3273
            m4 := mload(0x80)
3274
            // Selector of `log(address,address,uint256,address)`.
3275
            mstore(0x00, 0x8da6def5)
3276
            mstore(0x20, p0)
3277
            mstore(0x40, p1)
3278
            mstore(0x60, p2)
3279
            mstore(0x80, p3)
3280
        }
3281
        _sendLogPayload(0x1c, 0x84);
3282
        /// @solidity memory-safe-assembly
3283
        assembly {
3284
            mstore(0x00, m0)
3285
            mstore(0x20, m1)
3286
            mstore(0x40, m2)
3287
            mstore(0x60, m3)
3288
            mstore(0x80, m4)
3289
        }
3290
    }
3291

                            
                        
3292
    function log(address p0, address p1, uint256 p2, bool p3) internal pure {
3293
        bytes32 m0;
3294
        bytes32 m1;
3295
        bytes32 m2;
3296
        bytes32 m3;
3297
        bytes32 m4;
3298
        /// @solidity memory-safe-assembly
3299
        assembly {
3300
            m0 := mload(0x00)
3301
            m1 := mload(0x20)
3302
            m2 := mload(0x40)
3303
            m3 := mload(0x60)
3304
            m4 := mload(0x80)
3305
            // Selector of `log(address,address,uint256,bool)`.
3306
            mstore(0x00, 0x9b4254e2)
3307
            mstore(0x20, p0)
3308
            mstore(0x40, p1)
3309
            mstore(0x60, p2)
3310
            mstore(0x80, p3)
3311
        }
3312
        _sendLogPayload(0x1c, 0x84);
3313
        /// @solidity memory-safe-assembly
3314
        assembly {
3315
            mstore(0x00, m0)
3316
            mstore(0x20, m1)
3317
            mstore(0x40, m2)
3318
            mstore(0x60, m3)
3319
            mstore(0x80, m4)
3320
        }
3321
    }
3322

                            
                        
3323
    function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
3324
        bytes32 m0;
3325
        bytes32 m1;
3326
        bytes32 m2;
3327
        bytes32 m3;
3328
        bytes32 m4;
3329
        /// @solidity memory-safe-assembly
3330
        assembly {
3331
            m0 := mload(0x00)
3332
            m1 := mload(0x20)
3333
            m2 := mload(0x40)
3334
            m3 := mload(0x60)
3335
            m4 := mload(0x80)
3336
            // Selector of `log(address,address,uint256,uint256)`.
3337
            mstore(0x00, 0xbe553481)
3338
            mstore(0x20, p0)
3339
            mstore(0x40, p1)
3340
            mstore(0x60, p2)
3341
            mstore(0x80, p3)
3342
        }
3343
        _sendLogPayload(0x1c, 0x84);
3344
        /// @solidity memory-safe-assembly
3345
        assembly {
3346
            mstore(0x00, m0)
3347
            mstore(0x20, m1)
3348
            mstore(0x40, m2)
3349
            mstore(0x60, m3)
3350
            mstore(0x80, m4)
3351
        }
3352
    }
3353

                            
                        
3354
    function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {
3355
        bytes32 m0;
3356
        bytes32 m1;
3357
        bytes32 m2;
3358
        bytes32 m3;
3359
        bytes32 m4;
3360
        bytes32 m5;
3361
        bytes32 m6;
3362
        /// @solidity memory-safe-assembly
3363
        assembly {
3364
            function writeString(pos, w) {
3365
                let length := 0
3366
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3367
                mstore(pos, length)
3368
                let shift := sub(256, shl(3, length))
3369
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3370
            }
3371
            m0 := mload(0x00)
3372
            m1 := mload(0x20)
3373
            m2 := mload(0x40)
3374
            m3 := mload(0x60)
3375
            m4 := mload(0x80)
3376
            m5 := mload(0xa0)
3377
            m6 := mload(0xc0)
3378
            // Selector of `log(address,address,uint256,string)`.
3379
            mstore(0x00, 0xfdb4f990)
3380
            mstore(0x20, p0)
3381
            mstore(0x40, p1)
3382
            mstore(0x60, p2)
3383
            mstore(0x80, 0x80)
3384
            writeString(0xa0, p3)
3385
        }
3386
        _sendLogPayload(0x1c, 0xc4);
3387
        /// @solidity memory-safe-assembly
3388
        assembly {
3389
            mstore(0x00, m0)
3390
            mstore(0x20, m1)
3391
            mstore(0x40, m2)
3392
            mstore(0x60, m3)
3393
            mstore(0x80, m4)
3394
            mstore(0xa0, m5)
3395
            mstore(0xc0, m6)
3396
        }
3397
    }
3398

                            
                        
3399
    function log(address p0, address p1, bytes32 p2, address p3) internal pure {
3400
        bytes32 m0;
3401
        bytes32 m1;
3402
        bytes32 m2;
3403
        bytes32 m3;
3404
        bytes32 m4;
3405
        bytes32 m5;
3406
        bytes32 m6;
3407
        /// @solidity memory-safe-assembly
3408
        assembly {
3409
            function writeString(pos, w) {
3410
                let length := 0
3411
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3412
                mstore(pos, length)
3413
                let shift := sub(256, shl(3, length))
3414
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3415
            }
3416
            m0 := mload(0x00)
3417
            m1 := mload(0x20)
3418
            m2 := mload(0x40)
3419
            m3 := mload(0x60)
3420
            m4 := mload(0x80)
3421
            m5 := mload(0xa0)
3422
            m6 := mload(0xc0)
3423
            // Selector of `log(address,address,string,address)`.
3424
            mstore(0x00, 0x8f736d16)
3425
            mstore(0x20, p0)
3426
            mstore(0x40, p1)
3427
            mstore(0x60, 0x80)
3428
            mstore(0x80, p3)
3429
            writeString(0xa0, p2)
3430
        }
3431
        _sendLogPayload(0x1c, 0xc4);
3432
        /// @solidity memory-safe-assembly
3433
        assembly {
3434
            mstore(0x00, m0)
3435
            mstore(0x20, m1)
3436
            mstore(0x40, m2)
3437
            mstore(0x60, m3)
3438
            mstore(0x80, m4)
3439
            mstore(0xa0, m5)
3440
            mstore(0xc0, m6)
3441
        }
3442
    }
3443

                            
                        
3444
    function log(address p0, address p1, bytes32 p2, bool p3) internal pure {
3445
        bytes32 m0;
3446
        bytes32 m1;
3447
        bytes32 m2;
3448
        bytes32 m3;
3449
        bytes32 m4;
3450
        bytes32 m5;
3451
        bytes32 m6;
3452
        /// @solidity memory-safe-assembly
3453
        assembly {
3454
            function writeString(pos, w) {
3455
                let length := 0
3456
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3457
                mstore(pos, length)
3458
                let shift := sub(256, shl(3, length))
3459
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3460
            }
3461
            m0 := mload(0x00)
3462
            m1 := mload(0x20)
3463
            m2 := mload(0x40)
3464
            m3 := mload(0x60)
3465
            m4 := mload(0x80)
3466
            m5 := mload(0xa0)
3467
            m6 := mload(0xc0)
3468
            // Selector of `log(address,address,string,bool)`.
3469
            mstore(0x00, 0x6f1a594e)
3470
            mstore(0x20, p0)
3471
            mstore(0x40, p1)
3472
            mstore(0x60, 0x80)
3473
            mstore(0x80, p3)
3474
            writeString(0xa0, p2)
3475
        }
3476
        _sendLogPayload(0x1c, 0xc4);
3477
        /// @solidity memory-safe-assembly
3478
        assembly {
3479
            mstore(0x00, m0)
3480
            mstore(0x20, m1)
3481
            mstore(0x40, m2)
3482
            mstore(0x60, m3)
3483
            mstore(0x80, m4)
3484
            mstore(0xa0, m5)
3485
            mstore(0xc0, m6)
3486
        }
3487
    }
3488

                            
                        
3489
    function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {
3490
        bytes32 m0;
3491
        bytes32 m1;
3492
        bytes32 m2;
3493
        bytes32 m3;
3494
        bytes32 m4;
3495
        bytes32 m5;
3496
        bytes32 m6;
3497
        /// @solidity memory-safe-assembly
3498
        assembly {
3499
            function writeString(pos, w) {
3500
                let length := 0
3501
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3502
                mstore(pos, length)
3503
                let shift := sub(256, shl(3, length))
3504
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3505
            }
3506
            m0 := mload(0x00)
3507
            m1 := mload(0x20)
3508
            m2 := mload(0x40)
3509
            m3 := mload(0x60)
3510
            m4 := mload(0x80)
3511
            m5 := mload(0xa0)
3512
            m6 := mload(0xc0)
3513
            // Selector of `log(address,address,string,uint256)`.
3514
            mstore(0x00, 0xef1cefe7)
3515
            mstore(0x20, p0)
3516
            mstore(0x40, p1)
3517
            mstore(0x60, 0x80)
3518
            mstore(0x80, p3)
3519
            writeString(0xa0, p2)
3520
        }
3521
        _sendLogPayload(0x1c, 0xc4);
3522
        /// @solidity memory-safe-assembly
3523
        assembly {
3524
            mstore(0x00, m0)
3525
            mstore(0x20, m1)
3526
            mstore(0x40, m2)
3527
            mstore(0x60, m3)
3528
            mstore(0x80, m4)
3529
            mstore(0xa0, m5)
3530
            mstore(0xc0, m6)
3531
        }
3532
    }
3533

                            
                        
3534
    function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {
3535
        bytes32 m0;
3536
        bytes32 m1;
3537
        bytes32 m2;
3538
        bytes32 m3;
3539
        bytes32 m4;
3540
        bytes32 m5;
3541
        bytes32 m6;
3542
        bytes32 m7;
3543
        bytes32 m8;
3544
        /// @solidity memory-safe-assembly
3545
        assembly {
3546
            function writeString(pos, w) {
3547
                let length := 0
3548
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3549
                mstore(pos, length)
3550
                let shift := sub(256, shl(3, length))
3551
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3552
            }
3553
            m0 := mload(0x00)
3554
            m1 := mload(0x20)
3555
            m2 := mload(0x40)
3556
            m3 := mload(0x60)
3557
            m4 := mload(0x80)
3558
            m5 := mload(0xa0)
3559
            m6 := mload(0xc0)
3560
            m7 := mload(0xe0)
3561
            m8 := mload(0x100)
3562
            // Selector of `log(address,address,string,string)`.
3563
            mstore(0x00, 0x21bdaf25)
3564
            mstore(0x20, p0)
3565
            mstore(0x40, p1)
3566
            mstore(0x60, 0x80)
3567
            mstore(0x80, 0xc0)
3568
            writeString(0xa0, p2)
3569
            writeString(0xe0, p3)
3570
        }
3571
        _sendLogPayload(0x1c, 0x104);
3572
        /// @solidity memory-safe-assembly
3573
        assembly {
3574
            mstore(0x00, m0)
3575
            mstore(0x20, m1)
3576
            mstore(0x40, m2)
3577
            mstore(0x60, m3)
3578
            mstore(0x80, m4)
3579
            mstore(0xa0, m5)
3580
            mstore(0xc0, m6)
3581
            mstore(0xe0, m7)
3582
            mstore(0x100, m8)
3583
        }
3584
    }
3585

                            
                        
3586
    function log(address p0, bool p1, address p2, address p3) internal pure {
3587
        bytes32 m0;
3588
        bytes32 m1;
3589
        bytes32 m2;
3590
        bytes32 m3;
3591
        bytes32 m4;
3592
        /// @solidity memory-safe-assembly
3593
        assembly {
3594
            m0 := mload(0x00)
3595
            m1 := mload(0x20)
3596
            m2 := mload(0x40)
3597
            m3 := mload(0x60)
3598
            m4 := mload(0x80)
3599
            // Selector of `log(address,bool,address,address)`.
3600
            mstore(0x00, 0x660375dd)
3601
            mstore(0x20, p0)
3602
            mstore(0x40, p1)
3603
            mstore(0x60, p2)
3604
            mstore(0x80, p3)
3605
        }
3606
        _sendLogPayload(0x1c, 0x84);
3607
        /// @solidity memory-safe-assembly
3608
        assembly {
3609
            mstore(0x00, m0)
3610
            mstore(0x20, m1)
3611
            mstore(0x40, m2)
3612
            mstore(0x60, m3)
3613
            mstore(0x80, m4)
3614
        }
3615
    }
3616

                            
                        
3617
    function log(address p0, bool p1, address p2, bool p3) internal pure {
3618
        bytes32 m0;
3619
        bytes32 m1;
3620
        bytes32 m2;
3621
        bytes32 m3;
3622
        bytes32 m4;
3623
        /// @solidity memory-safe-assembly
3624
        assembly {
3625
            m0 := mload(0x00)
3626
            m1 := mload(0x20)
3627
            m2 := mload(0x40)
3628
            m3 := mload(0x60)
3629
            m4 := mload(0x80)
3630
            // Selector of `log(address,bool,address,bool)`.
3631
            mstore(0x00, 0xa6f50b0f)
3632
            mstore(0x20, p0)
3633
            mstore(0x40, p1)
3634
            mstore(0x60, p2)
3635
            mstore(0x80, p3)
3636
        }
3637
        _sendLogPayload(0x1c, 0x84);
3638
        /// @solidity memory-safe-assembly
3639
        assembly {
3640
            mstore(0x00, m0)
3641
            mstore(0x20, m1)
3642
            mstore(0x40, m2)
3643
            mstore(0x60, m3)
3644
            mstore(0x80, m4)
3645
        }
3646
    }
3647

                            
                        
3648
    function log(address p0, bool p1, address p2, uint256 p3) internal pure {
3649
        bytes32 m0;
3650
        bytes32 m1;
3651
        bytes32 m2;
3652
        bytes32 m3;
3653
        bytes32 m4;
3654
        /// @solidity memory-safe-assembly
3655
        assembly {
3656
            m0 := mload(0x00)
3657
            m1 := mload(0x20)
3658
            m2 := mload(0x40)
3659
            m3 := mload(0x60)
3660
            m4 := mload(0x80)
3661
            // Selector of `log(address,bool,address,uint256)`.
3662
            mstore(0x00, 0xa75c59de)
3663
            mstore(0x20, p0)
3664
            mstore(0x40, p1)
3665
            mstore(0x60, p2)
3666
            mstore(0x80, p3)
3667
        }
3668
        _sendLogPayload(0x1c, 0x84);
3669
        /// @solidity memory-safe-assembly
3670
        assembly {
3671
            mstore(0x00, m0)
3672
            mstore(0x20, m1)
3673
            mstore(0x40, m2)
3674
            mstore(0x60, m3)
3675
            mstore(0x80, m4)
3676
        }
3677
    }
3678

                            
                        
3679
    function log(address p0, bool p1, address p2, bytes32 p3) internal pure {
3680
        bytes32 m0;
3681
        bytes32 m1;
3682
        bytes32 m2;
3683
        bytes32 m3;
3684
        bytes32 m4;
3685
        bytes32 m5;
3686
        bytes32 m6;
3687
        /// @solidity memory-safe-assembly
3688
        assembly {
3689
            function writeString(pos, w) {
3690
                let length := 0
3691
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3692
                mstore(pos, length)
3693
                let shift := sub(256, shl(3, length))
3694
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3695
            }
3696
            m0 := mload(0x00)
3697
            m1 := mload(0x20)
3698
            m2 := mload(0x40)
3699
            m3 := mload(0x60)
3700
            m4 := mload(0x80)
3701
            m5 := mload(0xa0)
3702
            m6 := mload(0xc0)
3703
            // Selector of `log(address,bool,address,string)`.
3704
            mstore(0x00, 0x2dd778e6)
3705
            mstore(0x20, p0)
3706
            mstore(0x40, p1)
3707
            mstore(0x60, p2)
3708
            mstore(0x80, 0x80)
3709
            writeString(0xa0, p3)
3710
        }
3711
        _sendLogPayload(0x1c, 0xc4);
3712
        /// @solidity memory-safe-assembly
3713
        assembly {
3714
            mstore(0x00, m0)
3715
            mstore(0x20, m1)
3716
            mstore(0x40, m2)
3717
            mstore(0x60, m3)
3718
            mstore(0x80, m4)
3719
            mstore(0xa0, m5)
3720
            mstore(0xc0, m6)
3721
        }
3722
    }
3723

                            
                        
3724
    function log(address p0, bool p1, bool p2, address p3) internal pure {
3725
        bytes32 m0;
3726
        bytes32 m1;
3727
        bytes32 m2;
3728
        bytes32 m3;
3729
        bytes32 m4;
3730
        /// @solidity memory-safe-assembly
3731
        assembly {
3732
            m0 := mload(0x00)
3733
            m1 := mload(0x20)
3734
            m2 := mload(0x40)
3735
            m3 := mload(0x60)
3736
            m4 := mload(0x80)
3737
            // Selector of `log(address,bool,bool,address)`.
3738
            mstore(0x00, 0xcf394485)
3739
            mstore(0x20, p0)
3740
            mstore(0x40, p1)
3741
            mstore(0x60, p2)
3742
            mstore(0x80, p3)
3743
        }
3744
        _sendLogPayload(0x1c, 0x84);
3745
        /// @solidity memory-safe-assembly
3746
        assembly {
3747
            mstore(0x00, m0)
3748
            mstore(0x20, m1)
3749
            mstore(0x40, m2)
3750
            mstore(0x60, m3)
3751
            mstore(0x80, m4)
3752
        }
3753
    }
3754

                            
                        
3755
    function log(address p0, bool p1, bool p2, bool p3) internal pure {
3756
        bytes32 m0;
3757
        bytes32 m1;
3758
        bytes32 m2;
3759
        bytes32 m3;
3760
        bytes32 m4;
3761
        /// @solidity memory-safe-assembly
3762
        assembly {
3763
            m0 := mload(0x00)
3764
            m1 := mload(0x20)
3765
            m2 := mload(0x40)
3766
            m3 := mload(0x60)
3767
            m4 := mload(0x80)
3768
            // Selector of `log(address,bool,bool,bool)`.
3769
            mstore(0x00, 0xcac43479)
3770
            mstore(0x20, p0)
3771
            mstore(0x40, p1)
3772
            mstore(0x60, p2)
3773
            mstore(0x80, p3)
3774
        }
3775
        _sendLogPayload(0x1c, 0x84);
3776
        /// @solidity memory-safe-assembly
3777
        assembly {
3778
            mstore(0x00, m0)
3779
            mstore(0x20, m1)
3780
            mstore(0x40, m2)
3781
            mstore(0x60, m3)
3782
            mstore(0x80, m4)
3783
        }
3784
    }
3785

                            
                        
3786
    function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
3787
        bytes32 m0;
3788
        bytes32 m1;
3789
        bytes32 m2;
3790
        bytes32 m3;
3791
        bytes32 m4;
3792
        /// @solidity memory-safe-assembly
3793
        assembly {
3794
            m0 := mload(0x00)
3795
            m1 := mload(0x20)
3796
            m2 := mload(0x40)
3797
            m3 := mload(0x60)
3798
            m4 := mload(0x80)
3799
            // Selector of `log(address,bool,bool,uint256)`.
3800
            mstore(0x00, 0x8c4e5de6)
3801
            mstore(0x20, p0)
3802
            mstore(0x40, p1)
3803
            mstore(0x60, p2)
3804
            mstore(0x80, p3)
3805
        }
3806
        _sendLogPayload(0x1c, 0x84);
3807
        /// @solidity memory-safe-assembly
3808
        assembly {
3809
            mstore(0x00, m0)
3810
            mstore(0x20, m1)
3811
            mstore(0x40, m2)
3812
            mstore(0x60, m3)
3813
            mstore(0x80, m4)
3814
        }
3815
    }
3816

                            
                        
3817
    function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {
3818
        bytes32 m0;
3819
        bytes32 m1;
3820
        bytes32 m2;
3821
        bytes32 m3;
3822
        bytes32 m4;
3823
        bytes32 m5;
3824
        bytes32 m6;
3825
        /// @solidity memory-safe-assembly
3826
        assembly {
3827
            function writeString(pos, w) {
3828
                let length := 0
3829
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3830
                mstore(pos, length)
3831
                let shift := sub(256, shl(3, length))
3832
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3833
            }
3834
            m0 := mload(0x00)
3835
            m1 := mload(0x20)
3836
            m2 := mload(0x40)
3837
            m3 := mload(0x60)
3838
            m4 := mload(0x80)
3839
            m5 := mload(0xa0)
3840
            m6 := mload(0xc0)
3841
            // Selector of `log(address,bool,bool,string)`.
3842
            mstore(0x00, 0xdfc4a2e8)
3843
            mstore(0x20, p0)
3844
            mstore(0x40, p1)
3845
            mstore(0x60, p2)
3846
            mstore(0x80, 0x80)
3847
            writeString(0xa0, p3)
3848
        }
3849
        _sendLogPayload(0x1c, 0xc4);
3850
        /// @solidity memory-safe-assembly
3851
        assembly {
3852
            mstore(0x00, m0)
3853
            mstore(0x20, m1)
3854
            mstore(0x40, m2)
3855
            mstore(0x60, m3)
3856
            mstore(0x80, m4)
3857
            mstore(0xa0, m5)
3858
            mstore(0xc0, m6)
3859
        }
3860
    }
3861

                            
                        
3862
    function log(address p0, bool p1, uint256 p2, address p3) internal pure {
3863
        bytes32 m0;
3864
        bytes32 m1;
3865
        bytes32 m2;
3866
        bytes32 m3;
3867
        bytes32 m4;
3868
        /// @solidity memory-safe-assembly
3869
        assembly {
3870
            m0 := mload(0x00)
3871
            m1 := mload(0x20)
3872
            m2 := mload(0x40)
3873
            m3 := mload(0x60)
3874
            m4 := mload(0x80)
3875
            // Selector of `log(address,bool,uint256,address)`.
3876
            mstore(0x00, 0xccf790a1)
3877
            mstore(0x20, p0)
3878
            mstore(0x40, p1)
3879
            mstore(0x60, p2)
3880
            mstore(0x80, p3)
3881
        }
3882
        _sendLogPayload(0x1c, 0x84);
3883
        /// @solidity memory-safe-assembly
3884
        assembly {
3885
            mstore(0x00, m0)
3886
            mstore(0x20, m1)
3887
            mstore(0x40, m2)
3888
            mstore(0x60, m3)
3889
            mstore(0x80, m4)
3890
        }
3891
    }
3892

                            
                        
3893
    function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
3894
        bytes32 m0;
3895
        bytes32 m1;
3896
        bytes32 m2;
3897
        bytes32 m3;
3898
        bytes32 m4;
3899
        /// @solidity memory-safe-assembly
3900
        assembly {
3901
            m0 := mload(0x00)
3902
            m1 := mload(0x20)
3903
            m2 := mload(0x40)
3904
            m3 := mload(0x60)
3905
            m4 := mload(0x80)
3906
            // Selector of `log(address,bool,uint256,bool)`.
3907
            mstore(0x00, 0xc4643e20)
3908
            mstore(0x20, p0)
3909
            mstore(0x40, p1)
3910
            mstore(0x60, p2)
3911
            mstore(0x80, p3)
3912
        }
3913
        _sendLogPayload(0x1c, 0x84);
3914
        /// @solidity memory-safe-assembly
3915
        assembly {
3916
            mstore(0x00, m0)
3917
            mstore(0x20, m1)
3918
            mstore(0x40, m2)
3919
            mstore(0x60, m3)
3920
            mstore(0x80, m4)
3921
        }
3922
    }
3923

                            
                        
3924
    function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
3925
        bytes32 m0;
3926
        bytes32 m1;
3927
        bytes32 m2;
3928
        bytes32 m3;
3929
        bytes32 m4;
3930
        /// @solidity memory-safe-assembly
3931
        assembly {
3932
            m0 := mload(0x00)
3933
            m1 := mload(0x20)
3934
            m2 := mload(0x40)
3935
            m3 := mload(0x60)
3936
            m4 := mload(0x80)
3937
            // Selector of `log(address,bool,uint256,uint256)`.
3938
            mstore(0x00, 0x386ff5f4)
3939
            mstore(0x20, p0)
3940
            mstore(0x40, p1)
3941
            mstore(0x60, p2)
3942
            mstore(0x80, p3)
3943
        }
3944
        _sendLogPayload(0x1c, 0x84);
3945
        /// @solidity memory-safe-assembly
3946
        assembly {
3947
            mstore(0x00, m0)
3948
            mstore(0x20, m1)
3949
            mstore(0x40, m2)
3950
            mstore(0x60, m3)
3951
            mstore(0x80, m4)
3952
        }
3953
    }
3954

                            
                        
3955
    function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {
3956
        bytes32 m0;
3957
        bytes32 m1;
3958
        bytes32 m2;
3959
        bytes32 m3;
3960
        bytes32 m4;
3961
        bytes32 m5;
3962
        bytes32 m6;
3963
        /// @solidity memory-safe-assembly
3964
        assembly {
3965
            function writeString(pos, w) {
3966
                let length := 0
3967
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
3968
                mstore(pos, length)
3969
                let shift := sub(256, shl(3, length))
3970
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
3971
            }
3972
            m0 := mload(0x00)
3973
            m1 := mload(0x20)
3974
            m2 := mload(0x40)
3975
            m3 := mload(0x60)
3976
            m4 := mload(0x80)
3977
            m5 := mload(0xa0)
3978
            m6 := mload(0xc0)
3979
            // Selector of `log(address,bool,uint256,string)`.
3980
            mstore(0x00, 0x0aa6cfad)
3981
            mstore(0x20, p0)
3982
            mstore(0x40, p1)
3983
            mstore(0x60, p2)
3984
            mstore(0x80, 0x80)
3985
            writeString(0xa0, p3)
3986
        }
3987
        _sendLogPayload(0x1c, 0xc4);
3988
        /// @solidity memory-safe-assembly
3989
        assembly {
3990
            mstore(0x00, m0)
3991
            mstore(0x20, m1)
3992
            mstore(0x40, m2)
3993
            mstore(0x60, m3)
3994
            mstore(0x80, m4)
3995
            mstore(0xa0, m5)
3996
            mstore(0xc0, m6)
3997
        }
3998
    }
3999

                            
                        
4000
    function log(address p0, bool p1, bytes32 p2, address p3) internal pure {
4001
        bytes32 m0;
4002
        bytes32 m1;
4003
        bytes32 m2;
4004
        bytes32 m3;
4005
        bytes32 m4;
4006
        bytes32 m5;
4007
        bytes32 m6;
4008
        /// @solidity memory-safe-assembly
4009
        assembly {
4010
            function writeString(pos, w) {
4011
                let length := 0
4012
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4013
                mstore(pos, length)
4014
                let shift := sub(256, shl(3, length))
4015
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4016
            }
4017
            m0 := mload(0x00)
4018
            m1 := mload(0x20)
4019
            m2 := mload(0x40)
4020
            m3 := mload(0x60)
4021
            m4 := mload(0x80)
4022
            m5 := mload(0xa0)
4023
            m6 := mload(0xc0)
4024
            // Selector of `log(address,bool,string,address)`.
4025
            mstore(0x00, 0x19fd4956)
4026
            mstore(0x20, p0)
4027
            mstore(0x40, p1)
4028
            mstore(0x60, 0x80)
4029
            mstore(0x80, p3)
4030
            writeString(0xa0, p2)
4031
        }
4032
        _sendLogPayload(0x1c, 0xc4);
4033
        /// @solidity memory-safe-assembly
4034
        assembly {
4035
            mstore(0x00, m0)
4036
            mstore(0x20, m1)
4037
            mstore(0x40, m2)
4038
            mstore(0x60, m3)
4039
            mstore(0x80, m4)
4040
            mstore(0xa0, m5)
4041
            mstore(0xc0, m6)
4042
        }
4043
    }
4044

                            
                        
4045
    function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {
4046
        bytes32 m0;
4047
        bytes32 m1;
4048
        bytes32 m2;
4049
        bytes32 m3;
4050
        bytes32 m4;
4051
        bytes32 m5;
4052
        bytes32 m6;
4053
        /// @solidity memory-safe-assembly
4054
        assembly {
4055
            function writeString(pos, w) {
4056
                let length := 0
4057
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4058
                mstore(pos, length)
4059
                let shift := sub(256, shl(3, length))
4060
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4061
            }
4062
            m0 := mload(0x00)
4063
            m1 := mload(0x20)
4064
            m2 := mload(0x40)
4065
            m3 := mload(0x60)
4066
            m4 := mload(0x80)
4067
            m5 := mload(0xa0)
4068
            m6 := mload(0xc0)
4069
            // Selector of `log(address,bool,string,bool)`.
4070
            mstore(0x00, 0x50ad461d)
4071
            mstore(0x20, p0)
4072
            mstore(0x40, p1)
4073
            mstore(0x60, 0x80)
4074
            mstore(0x80, p3)
4075
            writeString(0xa0, p2)
4076
        }
4077
        _sendLogPayload(0x1c, 0xc4);
4078
        /// @solidity memory-safe-assembly
4079
        assembly {
4080
            mstore(0x00, m0)
4081
            mstore(0x20, m1)
4082
            mstore(0x40, m2)
4083
            mstore(0x60, m3)
4084
            mstore(0x80, m4)
4085
            mstore(0xa0, m5)
4086
            mstore(0xc0, m6)
4087
        }
4088
    }
4089

                            
                        
4090
    function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {
4091
        bytes32 m0;
4092
        bytes32 m1;
4093
        bytes32 m2;
4094
        bytes32 m3;
4095
        bytes32 m4;
4096
        bytes32 m5;
4097
        bytes32 m6;
4098
        /// @solidity memory-safe-assembly
4099
        assembly {
4100
            function writeString(pos, w) {
4101
                let length := 0
4102
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4103
                mstore(pos, length)
4104
                let shift := sub(256, shl(3, length))
4105
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4106
            }
4107
            m0 := mload(0x00)
4108
            m1 := mload(0x20)
4109
            m2 := mload(0x40)
4110
            m3 := mload(0x60)
4111
            m4 := mload(0x80)
4112
            m5 := mload(0xa0)
4113
            m6 := mload(0xc0)
4114
            // Selector of `log(address,bool,string,uint256)`.
4115
            mstore(0x00, 0x80e6a20b)
4116
            mstore(0x20, p0)
4117
            mstore(0x40, p1)
4118
            mstore(0x60, 0x80)
4119
            mstore(0x80, p3)
4120
            writeString(0xa0, p2)
4121
        }
4122
        _sendLogPayload(0x1c, 0xc4);
4123
        /// @solidity memory-safe-assembly
4124
        assembly {
4125
            mstore(0x00, m0)
4126
            mstore(0x20, m1)
4127
            mstore(0x40, m2)
4128
            mstore(0x60, m3)
4129
            mstore(0x80, m4)
4130
            mstore(0xa0, m5)
4131
            mstore(0xc0, m6)
4132
        }
4133
    }
4134

                            
                        
4135
    function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
4136
        bytes32 m0;
4137
        bytes32 m1;
4138
        bytes32 m2;
4139
        bytes32 m3;
4140
        bytes32 m4;
4141
        bytes32 m5;
4142
        bytes32 m6;
4143
        bytes32 m7;
4144
        bytes32 m8;
4145
        /// @solidity memory-safe-assembly
4146
        assembly {
4147
            function writeString(pos, w) {
4148
                let length := 0
4149
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4150
                mstore(pos, length)
4151
                let shift := sub(256, shl(3, length))
4152
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4153
            }
4154
            m0 := mload(0x00)
4155
            m1 := mload(0x20)
4156
            m2 := mload(0x40)
4157
            m3 := mload(0x60)
4158
            m4 := mload(0x80)
4159
            m5 := mload(0xa0)
4160
            m6 := mload(0xc0)
4161
            m7 := mload(0xe0)
4162
            m8 := mload(0x100)
4163
            // Selector of `log(address,bool,string,string)`.
4164
            mstore(0x00, 0x475c5c33)
4165
            mstore(0x20, p0)
4166
            mstore(0x40, p1)
4167
            mstore(0x60, 0x80)
4168
            mstore(0x80, 0xc0)
4169
            writeString(0xa0, p2)
4170
            writeString(0xe0, p3)
4171
        }
4172
        _sendLogPayload(0x1c, 0x104);
4173
        /// @solidity memory-safe-assembly
4174
        assembly {
4175
            mstore(0x00, m0)
4176
            mstore(0x20, m1)
4177
            mstore(0x40, m2)
4178
            mstore(0x60, m3)
4179
            mstore(0x80, m4)
4180
            mstore(0xa0, m5)
4181
            mstore(0xc0, m6)
4182
            mstore(0xe0, m7)
4183
            mstore(0x100, m8)
4184
        }
4185
    }
4186

                            
                        
4187
    function log(address p0, uint256 p1, address p2, address p3) internal pure {
4188
        bytes32 m0;
4189
        bytes32 m1;
4190
        bytes32 m2;
4191
        bytes32 m3;
4192
        bytes32 m4;
4193
        /// @solidity memory-safe-assembly
4194
        assembly {
4195
            m0 := mload(0x00)
4196
            m1 := mload(0x20)
4197
            m2 := mload(0x40)
4198
            m3 := mload(0x60)
4199
            m4 := mload(0x80)
4200
            // Selector of `log(address,uint256,address,address)`.
4201
            mstore(0x00, 0x478d1c62)
4202
            mstore(0x20, p0)
4203
            mstore(0x40, p1)
4204
            mstore(0x60, p2)
4205
            mstore(0x80, p3)
4206
        }
4207
        _sendLogPayload(0x1c, 0x84);
4208
        /// @solidity memory-safe-assembly
4209
        assembly {
4210
            mstore(0x00, m0)
4211
            mstore(0x20, m1)
4212
            mstore(0x40, m2)
4213
            mstore(0x60, m3)
4214
            mstore(0x80, m4)
4215
        }
4216
    }
4217

                            
                        
4218
    function log(address p0, uint256 p1, address p2, bool p3) internal pure {
4219
        bytes32 m0;
4220
        bytes32 m1;
4221
        bytes32 m2;
4222
        bytes32 m3;
4223
        bytes32 m4;
4224
        /// @solidity memory-safe-assembly
4225
        assembly {
4226
            m0 := mload(0x00)
4227
            m1 := mload(0x20)
4228
            m2 := mload(0x40)
4229
            m3 := mload(0x60)
4230
            m4 := mload(0x80)
4231
            // Selector of `log(address,uint256,address,bool)`.
4232
            mstore(0x00, 0xa1bcc9b3)
4233
            mstore(0x20, p0)
4234
            mstore(0x40, p1)
4235
            mstore(0x60, p2)
4236
            mstore(0x80, p3)
4237
        }
4238
        _sendLogPayload(0x1c, 0x84);
4239
        /// @solidity memory-safe-assembly
4240
        assembly {
4241
            mstore(0x00, m0)
4242
            mstore(0x20, m1)
4243
            mstore(0x40, m2)
4244
            mstore(0x60, m3)
4245
            mstore(0x80, m4)
4246
        }
4247
    }
4248

                            
                        
4249
    function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
4250
        bytes32 m0;
4251
        bytes32 m1;
4252
        bytes32 m2;
4253
        bytes32 m3;
4254
        bytes32 m4;
4255
        /// @solidity memory-safe-assembly
4256
        assembly {
4257
            m0 := mload(0x00)
4258
            m1 := mload(0x20)
4259
            m2 := mload(0x40)
4260
            m3 := mload(0x60)
4261
            m4 := mload(0x80)
4262
            // Selector of `log(address,uint256,address,uint256)`.
4263
            mstore(0x00, 0x100f650e)
4264
            mstore(0x20, p0)
4265
            mstore(0x40, p1)
4266
            mstore(0x60, p2)
4267
            mstore(0x80, p3)
4268
        }
4269
        _sendLogPayload(0x1c, 0x84);
4270
        /// @solidity memory-safe-assembly
4271
        assembly {
4272
            mstore(0x00, m0)
4273
            mstore(0x20, m1)
4274
            mstore(0x40, m2)
4275
            mstore(0x60, m3)
4276
            mstore(0x80, m4)
4277
        }
4278
    }
4279

                            
                        
4280
    function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {
4281
        bytes32 m0;
4282
        bytes32 m1;
4283
        bytes32 m2;
4284
        bytes32 m3;
4285
        bytes32 m4;
4286
        bytes32 m5;
4287
        bytes32 m6;
4288
        /// @solidity memory-safe-assembly
4289
        assembly {
4290
            function writeString(pos, w) {
4291
                let length := 0
4292
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4293
                mstore(pos, length)
4294
                let shift := sub(256, shl(3, length))
4295
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4296
            }
4297
            m0 := mload(0x00)
4298
            m1 := mload(0x20)
4299
            m2 := mload(0x40)
4300
            m3 := mload(0x60)
4301
            m4 := mload(0x80)
4302
            m5 := mload(0xa0)
4303
            m6 := mload(0xc0)
4304
            // Selector of `log(address,uint256,address,string)`.
4305
            mstore(0x00, 0x1da986ea)
4306
            mstore(0x20, p0)
4307
            mstore(0x40, p1)
4308
            mstore(0x60, p2)
4309
            mstore(0x80, 0x80)
4310
            writeString(0xa0, p3)
4311
        }
4312
        _sendLogPayload(0x1c, 0xc4);
4313
        /// @solidity memory-safe-assembly
4314
        assembly {
4315
            mstore(0x00, m0)
4316
            mstore(0x20, m1)
4317
            mstore(0x40, m2)
4318
            mstore(0x60, m3)
4319
            mstore(0x80, m4)
4320
            mstore(0xa0, m5)
4321
            mstore(0xc0, m6)
4322
        }
4323
    }
4324

                            
                        
4325
    function log(address p0, uint256 p1, bool p2, address p3) internal pure {
4326
        bytes32 m0;
4327
        bytes32 m1;
4328
        bytes32 m2;
4329
        bytes32 m3;
4330
        bytes32 m4;
4331
        /// @solidity memory-safe-assembly
4332
        assembly {
4333
            m0 := mload(0x00)
4334
            m1 := mload(0x20)
4335
            m2 := mload(0x40)
4336
            m3 := mload(0x60)
4337
            m4 := mload(0x80)
4338
            // Selector of `log(address,uint256,bool,address)`.
4339
            mstore(0x00, 0xa31bfdcc)
4340
            mstore(0x20, p0)
4341
            mstore(0x40, p1)
4342
            mstore(0x60, p2)
4343
            mstore(0x80, p3)
4344
        }
4345
        _sendLogPayload(0x1c, 0x84);
4346
        /// @solidity memory-safe-assembly
4347
        assembly {
4348
            mstore(0x00, m0)
4349
            mstore(0x20, m1)
4350
            mstore(0x40, m2)
4351
            mstore(0x60, m3)
4352
            mstore(0x80, m4)
4353
        }
4354
    }
4355

                            
                        
4356
    function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
4357
        bytes32 m0;
4358
        bytes32 m1;
4359
        bytes32 m2;
4360
        bytes32 m3;
4361
        bytes32 m4;
4362
        /// @solidity memory-safe-assembly
4363
        assembly {
4364
            m0 := mload(0x00)
4365
            m1 := mload(0x20)
4366
            m2 := mload(0x40)
4367
            m3 := mload(0x60)
4368
            m4 := mload(0x80)
4369
            // Selector of `log(address,uint256,bool,bool)`.
4370
            mstore(0x00, 0x3bf5e537)
4371
            mstore(0x20, p0)
4372
            mstore(0x40, p1)
4373
            mstore(0x60, p2)
4374
            mstore(0x80, p3)
4375
        }
4376
        _sendLogPayload(0x1c, 0x84);
4377
        /// @solidity memory-safe-assembly
4378
        assembly {
4379
            mstore(0x00, m0)
4380
            mstore(0x20, m1)
4381
            mstore(0x40, m2)
4382
            mstore(0x60, m3)
4383
            mstore(0x80, m4)
4384
        }
4385
    }
4386

                            
                        
4387
    function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
4388
        bytes32 m0;
4389
        bytes32 m1;
4390
        bytes32 m2;
4391
        bytes32 m3;
4392
        bytes32 m4;
4393
        /// @solidity memory-safe-assembly
4394
        assembly {
4395
            m0 := mload(0x00)
4396
            m1 := mload(0x20)
4397
            m2 := mload(0x40)
4398
            m3 := mload(0x60)
4399
            m4 := mload(0x80)
4400
            // Selector of `log(address,uint256,bool,uint256)`.
4401
            mstore(0x00, 0x22f6b999)
4402
            mstore(0x20, p0)
4403
            mstore(0x40, p1)
4404
            mstore(0x60, p2)
4405
            mstore(0x80, p3)
4406
        }
4407
        _sendLogPayload(0x1c, 0x84);
4408
        /// @solidity memory-safe-assembly
4409
        assembly {
4410
            mstore(0x00, m0)
4411
            mstore(0x20, m1)
4412
            mstore(0x40, m2)
4413
            mstore(0x60, m3)
4414
            mstore(0x80, m4)
4415
        }
4416
    }
4417

                            
                        
4418
    function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {
4419
        bytes32 m0;
4420
        bytes32 m1;
4421
        bytes32 m2;
4422
        bytes32 m3;
4423
        bytes32 m4;
4424
        bytes32 m5;
4425
        bytes32 m6;
4426
        /// @solidity memory-safe-assembly
4427
        assembly {
4428
            function writeString(pos, w) {
4429
                let length := 0
4430
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4431
                mstore(pos, length)
4432
                let shift := sub(256, shl(3, length))
4433
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4434
            }
4435
            m0 := mload(0x00)
4436
            m1 := mload(0x20)
4437
            m2 := mload(0x40)
4438
            m3 := mload(0x60)
4439
            m4 := mload(0x80)
4440
            m5 := mload(0xa0)
4441
            m6 := mload(0xc0)
4442
            // Selector of `log(address,uint256,bool,string)`.
4443
            mstore(0x00, 0xc5ad85f9)
4444
            mstore(0x20, p0)
4445
            mstore(0x40, p1)
4446
            mstore(0x60, p2)
4447
            mstore(0x80, 0x80)
4448
            writeString(0xa0, p3)
4449
        }
4450
        _sendLogPayload(0x1c, 0xc4);
4451
        /// @solidity memory-safe-assembly
4452
        assembly {
4453
            mstore(0x00, m0)
4454
            mstore(0x20, m1)
4455
            mstore(0x40, m2)
4456
            mstore(0x60, m3)
4457
            mstore(0x80, m4)
4458
            mstore(0xa0, m5)
4459
            mstore(0xc0, m6)
4460
        }
4461
    }
4462

                            
                        
4463
    function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
4464
        bytes32 m0;
4465
        bytes32 m1;
4466
        bytes32 m2;
4467
        bytes32 m3;
4468
        bytes32 m4;
4469
        /// @solidity memory-safe-assembly
4470
        assembly {
4471
            m0 := mload(0x00)
4472
            m1 := mload(0x20)
4473
            m2 := mload(0x40)
4474
            m3 := mload(0x60)
4475
            m4 := mload(0x80)
4476
            // Selector of `log(address,uint256,uint256,address)`.
4477
            mstore(0x00, 0x20e3984d)
4478
            mstore(0x20, p0)
4479
            mstore(0x40, p1)
4480
            mstore(0x60, p2)
4481
            mstore(0x80, p3)
4482
        }
4483
        _sendLogPayload(0x1c, 0x84);
4484
        /// @solidity memory-safe-assembly
4485
        assembly {
4486
            mstore(0x00, m0)
4487
            mstore(0x20, m1)
4488
            mstore(0x40, m2)
4489
            mstore(0x60, m3)
4490
            mstore(0x80, m4)
4491
        }
4492
    }
4493

                            
                        
4494
    function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
4495
        bytes32 m0;
4496
        bytes32 m1;
4497
        bytes32 m2;
4498
        bytes32 m3;
4499
        bytes32 m4;
4500
        /// @solidity memory-safe-assembly
4501
        assembly {
4502
            m0 := mload(0x00)
4503
            m1 := mload(0x20)
4504
            m2 := mload(0x40)
4505
            m3 := mload(0x60)
4506
            m4 := mload(0x80)
4507
            // Selector of `log(address,uint256,uint256,bool)`.
4508
            mstore(0x00, 0x66f1bc67)
4509
            mstore(0x20, p0)
4510
            mstore(0x40, p1)
4511
            mstore(0x60, p2)
4512
            mstore(0x80, p3)
4513
        }
4514
        _sendLogPayload(0x1c, 0x84);
4515
        /// @solidity memory-safe-assembly
4516
        assembly {
4517
            mstore(0x00, m0)
4518
            mstore(0x20, m1)
4519
            mstore(0x40, m2)
4520
            mstore(0x60, m3)
4521
            mstore(0x80, m4)
4522
        }
4523
    }
4524

                            
                        
4525
    function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
4526
        bytes32 m0;
4527
        bytes32 m1;
4528
        bytes32 m2;
4529
        bytes32 m3;
4530
        bytes32 m4;
4531
        /// @solidity memory-safe-assembly
4532
        assembly {
4533
            m0 := mload(0x00)
4534
            m1 := mload(0x20)
4535
            m2 := mload(0x40)
4536
            m3 := mload(0x60)
4537
            m4 := mload(0x80)
4538
            // Selector of `log(address,uint256,uint256,uint256)`.
4539
            mstore(0x00, 0x34f0e636)
4540
            mstore(0x20, p0)
4541
            mstore(0x40, p1)
4542
            mstore(0x60, p2)
4543
            mstore(0x80, p3)
4544
        }
4545
        _sendLogPayload(0x1c, 0x84);
4546
        /// @solidity memory-safe-assembly
4547
        assembly {
4548
            mstore(0x00, m0)
4549
            mstore(0x20, m1)
4550
            mstore(0x40, m2)
4551
            mstore(0x60, m3)
4552
            mstore(0x80, m4)
4553
        }
4554
    }
4555

                            
                        
4556
    function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
4557
        bytes32 m0;
4558
        bytes32 m1;
4559
        bytes32 m2;
4560
        bytes32 m3;
4561
        bytes32 m4;
4562
        bytes32 m5;
4563
        bytes32 m6;
4564
        /// @solidity memory-safe-assembly
4565
        assembly {
4566
            function writeString(pos, w) {
4567
                let length := 0
4568
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4569
                mstore(pos, length)
4570
                let shift := sub(256, shl(3, length))
4571
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4572
            }
4573
            m0 := mload(0x00)
4574
            m1 := mload(0x20)
4575
            m2 := mload(0x40)
4576
            m3 := mload(0x60)
4577
            m4 := mload(0x80)
4578
            m5 := mload(0xa0)
4579
            m6 := mload(0xc0)
4580
            // Selector of `log(address,uint256,uint256,string)`.
4581
            mstore(0x00, 0x4a28c017)
4582
            mstore(0x20, p0)
4583
            mstore(0x40, p1)
4584
            mstore(0x60, p2)
4585
            mstore(0x80, 0x80)
4586
            writeString(0xa0, p3)
4587
        }
4588
        _sendLogPayload(0x1c, 0xc4);
4589
        /// @solidity memory-safe-assembly
4590
        assembly {
4591
            mstore(0x00, m0)
4592
            mstore(0x20, m1)
4593
            mstore(0x40, m2)
4594
            mstore(0x60, m3)
4595
            mstore(0x80, m4)
4596
            mstore(0xa0, m5)
4597
            mstore(0xc0, m6)
4598
        }
4599
    }
4600

                            
                        
4601
    function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {
4602
        bytes32 m0;
4603
        bytes32 m1;
4604
        bytes32 m2;
4605
        bytes32 m3;
4606
        bytes32 m4;
4607
        bytes32 m5;
4608
        bytes32 m6;
4609
        /// @solidity memory-safe-assembly
4610
        assembly {
4611
            function writeString(pos, w) {
4612
                let length := 0
4613
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4614
                mstore(pos, length)
4615
                let shift := sub(256, shl(3, length))
4616
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4617
            }
4618
            m0 := mload(0x00)
4619
            m1 := mload(0x20)
4620
            m2 := mload(0x40)
4621
            m3 := mload(0x60)
4622
            m4 := mload(0x80)
4623
            m5 := mload(0xa0)
4624
            m6 := mload(0xc0)
4625
            // Selector of `log(address,uint256,string,address)`.
4626
            mstore(0x00, 0x5c430d47)
4627
            mstore(0x20, p0)
4628
            mstore(0x40, p1)
4629
            mstore(0x60, 0x80)
4630
            mstore(0x80, p3)
4631
            writeString(0xa0, p2)
4632
        }
4633
        _sendLogPayload(0x1c, 0xc4);
4634
        /// @solidity memory-safe-assembly
4635
        assembly {
4636
            mstore(0x00, m0)
4637
            mstore(0x20, m1)
4638
            mstore(0x40, m2)
4639
            mstore(0x60, m3)
4640
            mstore(0x80, m4)
4641
            mstore(0xa0, m5)
4642
            mstore(0xc0, m6)
4643
        }
4644
    }
4645

                            
                        
4646
    function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {
4647
        bytes32 m0;
4648
        bytes32 m1;
4649
        bytes32 m2;
4650
        bytes32 m3;
4651
        bytes32 m4;
4652
        bytes32 m5;
4653
        bytes32 m6;
4654
        /// @solidity memory-safe-assembly
4655
        assembly {
4656
            function writeString(pos, w) {
4657
                let length := 0
4658
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4659
                mstore(pos, length)
4660
                let shift := sub(256, shl(3, length))
4661
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4662
            }
4663
            m0 := mload(0x00)
4664
            m1 := mload(0x20)
4665
            m2 := mload(0x40)
4666
            m3 := mload(0x60)
4667
            m4 := mload(0x80)
4668
            m5 := mload(0xa0)
4669
            m6 := mload(0xc0)
4670
            // Selector of `log(address,uint256,string,bool)`.
4671
            mstore(0x00, 0xcf18105c)
4672
            mstore(0x20, p0)
4673
            mstore(0x40, p1)
4674
            mstore(0x60, 0x80)
4675
            mstore(0x80, p3)
4676
            writeString(0xa0, p2)
4677
        }
4678
        _sendLogPayload(0x1c, 0xc4);
4679
        /// @solidity memory-safe-assembly
4680
        assembly {
4681
            mstore(0x00, m0)
4682
            mstore(0x20, m1)
4683
            mstore(0x40, m2)
4684
            mstore(0x60, m3)
4685
            mstore(0x80, m4)
4686
            mstore(0xa0, m5)
4687
            mstore(0xc0, m6)
4688
        }
4689
    }
4690

                            
                        
4691
    function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
4692
        bytes32 m0;
4693
        bytes32 m1;
4694
        bytes32 m2;
4695
        bytes32 m3;
4696
        bytes32 m4;
4697
        bytes32 m5;
4698
        bytes32 m6;
4699
        /// @solidity memory-safe-assembly
4700
        assembly {
4701
            function writeString(pos, w) {
4702
                let length := 0
4703
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4704
                mstore(pos, length)
4705
                let shift := sub(256, shl(3, length))
4706
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4707
            }
4708
            m0 := mload(0x00)
4709
            m1 := mload(0x20)
4710
            m2 := mload(0x40)
4711
            m3 := mload(0x60)
4712
            m4 := mload(0x80)
4713
            m5 := mload(0xa0)
4714
            m6 := mload(0xc0)
4715
            // Selector of `log(address,uint256,string,uint256)`.
4716
            mstore(0x00, 0xbf01f891)
4717
            mstore(0x20, p0)
4718
            mstore(0x40, p1)
4719
            mstore(0x60, 0x80)
4720
            mstore(0x80, p3)
4721
            writeString(0xa0, p2)
4722
        }
4723
        _sendLogPayload(0x1c, 0xc4);
4724
        /// @solidity memory-safe-assembly
4725
        assembly {
4726
            mstore(0x00, m0)
4727
            mstore(0x20, m1)
4728
            mstore(0x40, m2)
4729
            mstore(0x60, m3)
4730
            mstore(0x80, m4)
4731
            mstore(0xa0, m5)
4732
            mstore(0xc0, m6)
4733
        }
4734
    }
4735

                            
                        
4736
    function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
4737
        bytes32 m0;
4738
        bytes32 m1;
4739
        bytes32 m2;
4740
        bytes32 m3;
4741
        bytes32 m4;
4742
        bytes32 m5;
4743
        bytes32 m6;
4744
        bytes32 m7;
4745
        bytes32 m8;
4746
        /// @solidity memory-safe-assembly
4747
        assembly {
4748
            function writeString(pos, w) {
4749
                let length := 0
4750
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4751
                mstore(pos, length)
4752
                let shift := sub(256, shl(3, length))
4753
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4754
            }
4755
            m0 := mload(0x00)
4756
            m1 := mload(0x20)
4757
            m2 := mload(0x40)
4758
            m3 := mload(0x60)
4759
            m4 := mload(0x80)
4760
            m5 := mload(0xa0)
4761
            m6 := mload(0xc0)
4762
            m7 := mload(0xe0)
4763
            m8 := mload(0x100)
4764
            // Selector of `log(address,uint256,string,string)`.
4765
            mstore(0x00, 0x88a8c406)
4766
            mstore(0x20, p0)
4767
            mstore(0x40, p1)
4768
            mstore(0x60, 0x80)
4769
            mstore(0x80, 0xc0)
4770
            writeString(0xa0, p2)
4771
            writeString(0xe0, p3)
4772
        }
4773
        _sendLogPayload(0x1c, 0x104);
4774
        /// @solidity memory-safe-assembly
4775
        assembly {
4776
            mstore(0x00, m0)
4777
            mstore(0x20, m1)
4778
            mstore(0x40, m2)
4779
            mstore(0x60, m3)
4780
            mstore(0x80, m4)
4781
            mstore(0xa0, m5)
4782
            mstore(0xc0, m6)
4783
            mstore(0xe0, m7)
4784
            mstore(0x100, m8)
4785
        }
4786
    }
4787

                            
                        
4788
    function log(address p0, bytes32 p1, address p2, address p3) internal pure {
4789
        bytes32 m0;
4790
        bytes32 m1;
4791
        bytes32 m2;
4792
        bytes32 m3;
4793
        bytes32 m4;
4794
        bytes32 m5;
4795
        bytes32 m6;
4796
        /// @solidity memory-safe-assembly
4797
        assembly {
4798
            function writeString(pos, w) {
4799
                let length := 0
4800
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4801
                mstore(pos, length)
4802
                let shift := sub(256, shl(3, length))
4803
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4804
            }
4805
            m0 := mload(0x00)
4806
            m1 := mload(0x20)
4807
            m2 := mload(0x40)
4808
            m3 := mload(0x60)
4809
            m4 := mload(0x80)
4810
            m5 := mload(0xa0)
4811
            m6 := mload(0xc0)
4812
            // Selector of `log(address,string,address,address)`.
4813
            mstore(0x00, 0x0d36fa20)
4814
            mstore(0x20, p0)
4815
            mstore(0x40, 0x80)
4816
            mstore(0x60, p2)
4817
            mstore(0x80, p3)
4818
            writeString(0xa0, p1)
4819
        }
4820
        _sendLogPayload(0x1c, 0xc4);
4821
        /// @solidity memory-safe-assembly
4822
        assembly {
4823
            mstore(0x00, m0)
4824
            mstore(0x20, m1)
4825
            mstore(0x40, m2)
4826
            mstore(0x60, m3)
4827
            mstore(0x80, m4)
4828
            mstore(0xa0, m5)
4829
            mstore(0xc0, m6)
4830
        }
4831
    }
4832

                            
                        
4833
    function log(address p0, bytes32 p1, address p2, bool p3) internal pure {
4834
        bytes32 m0;
4835
        bytes32 m1;
4836
        bytes32 m2;
4837
        bytes32 m3;
4838
        bytes32 m4;
4839
        bytes32 m5;
4840
        bytes32 m6;
4841
        /// @solidity memory-safe-assembly
4842
        assembly {
4843
            function writeString(pos, w) {
4844
                let length := 0
4845
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4846
                mstore(pos, length)
4847
                let shift := sub(256, shl(3, length))
4848
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4849
            }
4850
            m0 := mload(0x00)
4851
            m1 := mload(0x20)
4852
            m2 := mload(0x40)
4853
            m3 := mload(0x60)
4854
            m4 := mload(0x80)
4855
            m5 := mload(0xa0)
4856
            m6 := mload(0xc0)
4857
            // Selector of `log(address,string,address,bool)`.
4858
            mstore(0x00, 0x0df12b76)
4859
            mstore(0x20, p0)
4860
            mstore(0x40, 0x80)
4861
            mstore(0x60, p2)
4862
            mstore(0x80, p3)
4863
            writeString(0xa0, p1)
4864
        }
4865
        _sendLogPayload(0x1c, 0xc4);
4866
        /// @solidity memory-safe-assembly
4867
        assembly {
4868
            mstore(0x00, m0)
4869
            mstore(0x20, m1)
4870
            mstore(0x40, m2)
4871
            mstore(0x60, m3)
4872
            mstore(0x80, m4)
4873
            mstore(0xa0, m5)
4874
            mstore(0xc0, m6)
4875
        }
4876
    }
4877

                            
                        
4878
    function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {
4879
        bytes32 m0;
4880
        bytes32 m1;
4881
        bytes32 m2;
4882
        bytes32 m3;
4883
        bytes32 m4;
4884
        bytes32 m5;
4885
        bytes32 m6;
4886
        /// @solidity memory-safe-assembly
4887
        assembly {
4888
            function writeString(pos, w) {
4889
                let length := 0
4890
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4891
                mstore(pos, length)
4892
                let shift := sub(256, shl(3, length))
4893
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4894
            }
4895
            m0 := mload(0x00)
4896
            m1 := mload(0x20)
4897
            m2 := mload(0x40)
4898
            m3 := mload(0x60)
4899
            m4 := mload(0x80)
4900
            m5 := mload(0xa0)
4901
            m6 := mload(0xc0)
4902
            // Selector of `log(address,string,address,uint256)`.
4903
            mstore(0x00, 0x457fe3cf)
4904
            mstore(0x20, p0)
4905
            mstore(0x40, 0x80)
4906
            mstore(0x60, p2)
4907
            mstore(0x80, p3)
4908
            writeString(0xa0, p1)
4909
        }
4910
        _sendLogPayload(0x1c, 0xc4);
4911
        /// @solidity memory-safe-assembly
4912
        assembly {
4913
            mstore(0x00, m0)
4914
            mstore(0x20, m1)
4915
            mstore(0x40, m2)
4916
            mstore(0x60, m3)
4917
            mstore(0x80, m4)
4918
            mstore(0xa0, m5)
4919
            mstore(0xc0, m6)
4920
        }
4921
    }
4922

                            
                        
4923
    function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {
4924
        bytes32 m0;
4925
        bytes32 m1;
4926
        bytes32 m2;
4927
        bytes32 m3;
4928
        bytes32 m4;
4929
        bytes32 m5;
4930
        bytes32 m6;
4931
        bytes32 m7;
4932
        bytes32 m8;
4933
        /// @solidity memory-safe-assembly
4934
        assembly {
4935
            function writeString(pos, w) {
4936
                let length := 0
4937
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4938
                mstore(pos, length)
4939
                let shift := sub(256, shl(3, length))
4940
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4941
            }
4942
            m0 := mload(0x00)
4943
            m1 := mload(0x20)
4944
            m2 := mload(0x40)
4945
            m3 := mload(0x60)
4946
            m4 := mload(0x80)
4947
            m5 := mload(0xa0)
4948
            m6 := mload(0xc0)
4949
            m7 := mload(0xe0)
4950
            m8 := mload(0x100)
4951
            // Selector of `log(address,string,address,string)`.
4952
            mstore(0x00, 0xf7e36245)
4953
            mstore(0x20, p0)
4954
            mstore(0x40, 0x80)
4955
            mstore(0x60, p2)
4956
            mstore(0x80, 0xc0)
4957
            writeString(0xa0, p1)
4958
            writeString(0xe0, p3)
4959
        }
4960
        _sendLogPayload(0x1c, 0x104);
4961
        /// @solidity memory-safe-assembly
4962
        assembly {
4963
            mstore(0x00, m0)
4964
            mstore(0x20, m1)
4965
            mstore(0x40, m2)
4966
            mstore(0x60, m3)
4967
            mstore(0x80, m4)
4968
            mstore(0xa0, m5)
4969
            mstore(0xc0, m6)
4970
            mstore(0xe0, m7)
4971
            mstore(0x100, m8)
4972
        }
4973
    }
4974

                            
                        
4975
    function log(address p0, bytes32 p1, bool p2, address p3) internal pure {
4976
        bytes32 m0;
4977
        bytes32 m1;
4978
        bytes32 m2;
4979
        bytes32 m3;
4980
        bytes32 m4;
4981
        bytes32 m5;
4982
        bytes32 m6;
4983
        /// @solidity memory-safe-assembly
4984
        assembly {
4985
            function writeString(pos, w) {
4986
                let length := 0
4987
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
4988
                mstore(pos, length)
4989
                let shift := sub(256, shl(3, length))
4990
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
4991
            }
4992
            m0 := mload(0x00)
4993
            m1 := mload(0x20)
4994
            m2 := mload(0x40)
4995
            m3 := mload(0x60)
4996
            m4 := mload(0x80)
4997
            m5 := mload(0xa0)
4998
            m6 := mload(0xc0)
4999
            // Selector of `log(address,string,bool,address)`.
5000
            mstore(0x00, 0x205871c2)
5001
            mstore(0x20, p0)
5002
            mstore(0x40, 0x80)
5003
            mstore(0x60, p2)
5004
            mstore(0x80, p3)
5005
            writeString(0xa0, p1)
5006
        }
5007
        _sendLogPayload(0x1c, 0xc4);
5008
        /// @solidity memory-safe-assembly
5009
        assembly {
5010
            mstore(0x00, m0)
5011
            mstore(0x20, m1)
5012
            mstore(0x40, m2)
5013
            mstore(0x60, m3)
5014
            mstore(0x80, m4)
5015
            mstore(0xa0, m5)
5016
            mstore(0xc0, m6)
5017
        }
5018
    }
5019

                            
                        
5020
    function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {
5021
        bytes32 m0;
5022
        bytes32 m1;
5023
        bytes32 m2;
5024
        bytes32 m3;
5025
        bytes32 m4;
5026
        bytes32 m5;
5027
        bytes32 m6;
5028
        /// @solidity memory-safe-assembly
5029
        assembly {
5030
            function writeString(pos, w) {
5031
                let length := 0
5032
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5033
                mstore(pos, length)
5034
                let shift := sub(256, shl(3, length))
5035
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5036
            }
5037
            m0 := mload(0x00)
5038
            m1 := mload(0x20)
5039
            m2 := mload(0x40)
5040
            m3 := mload(0x60)
5041
            m4 := mload(0x80)
5042
            m5 := mload(0xa0)
5043
            m6 := mload(0xc0)
5044
            // Selector of `log(address,string,bool,bool)`.
5045
            mstore(0x00, 0x5f1d5c9f)
5046
            mstore(0x20, p0)
5047
            mstore(0x40, 0x80)
5048
            mstore(0x60, p2)
5049
            mstore(0x80, p3)
5050
            writeString(0xa0, p1)
5051
        }
5052
        _sendLogPayload(0x1c, 0xc4);
5053
        /// @solidity memory-safe-assembly
5054
        assembly {
5055
            mstore(0x00, m0)
5056
            mstore(0x20, m1)
5057
            mstore(0x40, m2)
5058
            mstore(0x60, m3)
5059
            mstore(0x80, m4)
5060
            mstore(0xa0, m5)
5061
            mstore(0xc0, m6)
5062
        }
5063
    }
5064

                            
                        
5065
    function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {
5066
        bytes32 m0;
5067
        bytes32 m1;
5068
        bytes32 m2;
5069
        bytes32 m3;
5070
        bytes32 m4;
5071
        bytes32 m5;
5072
        bytes32 m6;
5073
        /// @solidity memory-safe-assembly
5074
        assembly {
5075
            function writeString(pos, w) {
5076
                let length := 0
5077
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5078
                mstore(pos, length)
5079
                let shift := sub(256, shl(3, length))
5080
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5081
            }
5082
            m0 := mload(0x00)
5083
            m1 := mload(0x20)
5084
            m2 := mload(0x40)
5085
            m3 := mload(0x60)
5086
            m4 := mload(0x80)
5087
            m5 := mload(0xa0)
5088
            m6 := mload(0xc0)
5089
            // Selector of `log(address,string,bool,uint256)`.
5090
            mstore(0x00, 0x515e38b6)
5091
            mstore(0x20, p0)
5092
            mstore(0x40, 0x80)
5093
            mstore(0x60, p2)
5094
            mstore(0x80, p3)
5095
            writeString(0xa0, p1)
5096
        }
5097
        _sendLogPayload(0x1c, 0xc4);
5098
        /// @solidity memory-safe-assembly
5099
        assembly {
5100
            mstore(0x00, m0)
5101
            mstore(0x20, m1)
5102
            mstore(0x40, m2)
5103
            mstore(0x60, m3)
5104
            mstore(0x80, m4)
5105
            mstore(0xa0, m5)
5106
            mstore(0xc0, m6)
5107
        }
5108
    }
5109

                            
                        
5110
    function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
5111
        bytes32 m0;
5112
        bytes32 m1;
5113
        bytes32 m2;
5114
        bytes32 m3;
5115
        bytes32 m4;
5116
        bytes32 m5;
5117
        bytes32 m6;
5118
        bytes32 m7;
5119
        bytes32 m8;
5120
        /// @solidity memory-safe-assembly
5121
        assembly {
5122
            function writeString(pos, w) {
5123
                let length := 0
5124
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5125
                mstore(pos, length)
5126
                let shift := sub(256, shl(3, length))
5127
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5128
            }
5129
            m0 := mload(0x00)
5130
            m1 := mload(0x20)
5131
            m2 := mload(0x40)
5132
            m3 := mload(0x60)
5133
            m4 := mload(0x80)
5134
            m5 := mload(0xa0)
5135
            m6 := mload(0xc0)
5136
            m7 := mload(0xe0)
5137
            m8 := mload(0x100)
5138
            // Selector of `log(address,string,bool,string)`.
5139
            mstore(0x00, 0xbc0b61fe)
5140
            mstore(0x20, p0)
5141
            mstore(0x40, 0x80)
5142
            mstore(0x60, p2)
5143
            mstore(0x80, 0xc0)
5144
            writeString(0xa0, p1)
5145
            writeString(0xe0, p3)
5146
        }
5147
        _sendLogPayload(0x1c, 0x104);
5148
        /// @solidity memory-safe-assembly
5149
        assembly {
5150
            mstore(0x00, m0)
5151
            mstore(0x20, m1)
5152
            mstore(0x40, m2)
5153
            mstore(0x60, m3)
5154
            mstore(0x80, m4)
5155
            mstore(0xa0, m5)
5156
            mstore(0xc0, m6)
5157
            mstore(0xe0, m7)
5158
            mstore(0x100, m8)
5159
        }
5160
    }
5161

                            
                        
5162
    function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {
5163
        bytes32 m0;
5164
        bytes32 m1;
5165
        bytes32 m2;
5166
        bytes32 m3;
5167
        bytes32 m4;
5168
        bytes32 m5;
5169
        bytes32 m6;
5170
        /// @solidity memory-safe-assembly
5171
        assembly {
5172
            function writeString(pos, w) {
5173
                let length := 0
5174
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5175
                mstore(pos, length)
5176
                let shift := sub(256, shl(3, length))
5177
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5178
            }
5179
            m0 := mload(0x00)
5180
            m1 := mload(0x20)
5181
            m2 := mload(0x40)
5182
            m3 := mload(0x60)
5183
            m4 := mload(0x80)
5184
            m5 := mload(0xa0)
5185
            m6 := mload(0xc0)
5186
            // Selector of `log(address,string,uint256,address)`.
5187
            mstore(0x00, 0x63183678)
5188
            mstore(0x20, p0)
5189
            mstore(0x40, 0x80)
5190
            mstore(0x60, p2)
5191
            mstore(0x80, p3)
5192
            writeString(0xa0, p1)
5193
        }
5194
        _sendLogPayload(0x1c, 0xc4);
5195
        /// @solidity memory-safe-assembly
5196
        assembly {
5197
            mstore(0x00, m0)
5198
            mstore(0x20, m1)
5199
            mstore(0x40, m2)
5200
            mstore(0x60, m3)
5201
            mstore(0x80, m4)
5202
            mstore(0xa0, m5)
5203
            mstore(0xc0, m6)
5204
        }
5205
    }
5206

                            
                        
5207
    function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {
5208
        bytes32 m0;
5209
        bytes32 m1;
5210
        bytes32 m2;
5211
        bytes32 m3;
5212
        bytes32 m4;
5213
        bytes32 m5;
5214
        bytes32 m6;
5215
        /// @solidity memory-safe-assembly
5216
        assembly {
5217
            function writeString(pos, w) {
5218
                let length := 0
5219
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5220
                mstore(pos, length)
5221
                let shift := sub(256, shl(3, length))
5222
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5223
            }
5224
            m0 := mload(0x00)
5225
            m1 := mload(0x20)
5226
            m2 := mload(0x40)
5227
            m3 := mload(0x60)
5228
            m4 := mload(0x80)
5229
            m5 := mload(0xa0)
5230
            m6 := mload(0xc0)
5231
            // Selector of `log(address,string,uint256,bool)`.
5232
            mstore(0x00, 0x0ef7e050)
5233
            mstore(0x20, p0)
5234
            mstore(0x40, 0x80)
5235
            mstore(0x60, p2)
5236
            mstore(0x80, p3)
5237
            writeString(0xa0, p1)
5238
        }
5239
        _sendLogPayload(0x1c, 0xc4);
5240
        /// @solidity memory-safe-assembly
5241
        assembly {
5242
            mstore(0x00, m0)
5243
            mstore(0x20, m1)
5244
            mstore(0x40, m2)
5245
            mstore(0x60, m3)
5246
            mstore(0x80, m4)
5247
            mstore(0xa0, m5)
5248
            mstore(0xc0, m6)
5249
        }
5250
    }
5251

                            
                        
5252
    function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
5253
        bytes32 m0;
5254
        bytes32 m1;
5255
        bytes32 m2;
5256
        bytes32 m3;
5257
        bytes32 m4;
5258
        bytes32 m5;
5259
        bytes32 m6;
5260
        /// @solidity memory-safe-assembly
5261
        assembly {
5262
            function writeString(pos, w) {
5263
                let length := 0
5264
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5265
                mstore(pos, length)
5266
                let shift := sub(256, shl(3, length))
5267
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5268
            }
5269
            m0 := mload(0x00)
5270
            m1 := mload(0x20)
5271
            m2 := mload(0x40)
5272
            m3 := mload(0x60)
5273
            m4 := mload(0x80)
5274
            m5 := mload(0xa0)
5275
            m6 := mload(0xc0)
5276
            // Selector of `log(address,string,uint256,uint256)`.
5277
            mstore(0x00, 0x1dc8e1b8)
5278
            mstore(0x20, p0)
5279
            mstore(0x40, 0x80)
5280
            mstore(0x60, p2)
5281
            mstore(0x80, p3)
5282
            writeString(0xa0, p1)
5283
        }
5284
        _sendLogPayload(0x1c, 0xc4);
5285
        /// @solidity memory-safe-assembly
5286
        assembly {
5287
            mstore(0x00, m0)
5288
            mstore(0x20, m1)
5289
            mstore(0x40, m2)
5290
            mstore(0x60, m3)
5291
            mstore(0x80, m4)
5292
            mstore(0xa0, m5)
5293
            mstore(0xc0, m6)
5294
        }
5295
    }
5296

                            
                        
5297
    function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
5298
        bytes32 m0;
5299
        bytes32 m1;
5300
        bytes32 m2;
5301
        bytes32 m3;
5302
        bytes32 m4;
5303
        bytes32 m5;
5304
        bytes32 m6;
5305
        bytes32 m7;
5306
        bytes32 m8;
5307
        /// @solidity memory-safe-assembly
5308
        assembly {
5309
            function writeString(pos, w) {
5310
                let length := 0
5311
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5312
                mstore(pos, length)
5313
                let shift := sub(256, shl(3, length))
5314
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5315
            }
5316
            m0 := mload(0x00)
5317
            m1 := mload(0x20)
5318
            m2 := mload(0x40)
5319
            m3 := mload(0x60)
5320
            m4 := mload(0x80)
5321
            m5 := mload(0xa0)
5322
            m6 := mload(0xc0)
5323
            m7 := mload(0xe0)
5324
            m8 := mload(0x100)
5325
            // Selector of `log(address,string,uint256,string)`.
5326
            mstore(0x00, 0x448830a8)
5327
            mstore(0x20, p0)
5328
            mstore(0x40, 0x80)
5329
            mstore(0x60, p2)
5330
            mstore(0x80, 0xc0)
5331
            writeString(0xa0, p1)
5332
            writeString(0xe0, p3)
5333
        }
5334
        _sendLogPayload(0x1c, 0x104);
5335
        /// @solidity memory-safe-assembly
5336
        assembly {
5337
            mstore(0x00, m0)
5338
            mstore(0x20, m1)
5339
            mstore(0x40, m2)
5340
            mstore(0x60, m3)
5341
            mstore(0x80, m4)
5342
            mstore(0xa0, m5)
5343
            mstore(0xc0, m6)
5344
            mstore(0xe0, m7)
5345
            mstore(0x100, m8)
5346
        }
5347
    }
5348

                            
                        
5349
    function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {
5350
        bytes32 m0;
5351
        bytes32 m1;
5352
        bytes32 m2;
5353
        bytes32 m3;
5354
        bytes32 m4;
5355
        bytes32 m5;
5356
        bytes32 m6;
5357
        bytes32 m7;
5358
        bytes32 m8;
5359
        /// @solidity memory-safe-assembly
5360
        assembly {
5361
            function writeString(pos, w) {
5362
                let length := 0
5363
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5364
                mstore(pos, length)
5365
                let shift := sub(256, shl(3, length))
5366
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5367
            }
5368
            m0 := mload(0x00)
5369
            m1 := mload(0x20)
5370
            m2 := mload(0x40)
5371
            m3 := mload(0x60)
5372
            m4 := mload(0x80)
5373
            m5 := mload(0xa0)
5374
            m6 := mload(0xc0)
5375
            m7 := mload(0xe0)
5376
            m8 := mload(0x100)
5377
            // Selector of `log(address,string,string,address)`.
5378
            mstore(0x00, 0xa04e2f87)
5379
            mstore(0x20, p0)
5380
            mstore(0x40, 0x80)
5381
            mstore(0x60, 0xc0)
5382
            mstore(0x80, p3)
5383
            writeString(0xa0, p1)
5384
            writeString(0xe0, p2)
5385
        }
5386
        _sendLogPayload(0x1c, 0x104);
5387
        /// @solidity memory-safe-assembly
5388
        assembly {
5389
            mstore(0x00, m0)
5390
            mstore(0x20, m1)
5391
            mstore(0x40, m2)
5392
            mstore(0x60, m3)
5393
            mstore(0x80, m4)
5394
            mstore(0xa0, m5)
5395
            mstore(0xc0, m6)
5396
            mstore(0xe0, m7)
5397
            mstore(0x100, m8)
5398
        }
5399
    }
5400

                            
                        
5401
    function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
5402
        bytes32 m0;
5403
        bytes32 m1;
5404
        bytes32 m2;
5405
        bytes32 m3;
5406
        bytes32 m4;
5407
        bytes32 m5;
5408
        bytes32 m6;
5409
        bytes32 m7;
5410
        bytes32 m8;
5411
        /// @solidity memory-safe-assembly
5412
        assembly {
5413
            function writeString(pos, w) {
5414
                let length := 0
5415
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5416
                mstore(pos, length)
5417
                let shift := sub(256, shl(3, length))
5418
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5419
            }
5420
            m0 := mload(0x00)
5421
            m1 := mload(0x20)
5422
            m2 := mload(0x40)
5423
            m3 := mload(0x60)
5424
            m4 := mload(0x80)
5425
            m5 := mload(0xa0)
5426
            m6 := mload(0xc0)
5427
            m7 := mload(0xe0)
5428
            m8 := mload(0x100)
5429
            // Selector of `log(address,string,string,bool)`.
5430
            mstore(0x00, 0x35a5071f)
5431
            mstore(0x20, p0)
5432
            mstore(0x40, 0x80)
5433
            mstore(0x60, 0xc0)
5434
            mstore(0x80, p3)
5435
            writeString(0xa0, p1)
5436
            writeString(0xe0, p2)
5437
        }
5438
        _sendLogPayload(0x1c, 0x104);
5439
        /// @solidity memory-safe-assembly
5440
        assembly {
5441
            mstore(0x00, m0)
5442
            mstore(0x20, m1)
5443
            mstore(0x40, m2)
5444
            mstore(0x60, m3)
5445
            mstore(0x80, m4)
5446
            mstore(0xa0, m5)
5447
            mstore(0xc0, m6)
5448
            mstore(0xe0, m7)
5449
            mstore(0x100, m8)
5450
        }
5451
    }
5452

                            
                        
5453
    function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
5454
        bytes32 m0;
5455
        bytes32 m1;
5456
        bytes32 m2;
5457
        bytes32 m3;
5458
        bytes32 m4;
5459
        bytes32 m5;
5460
        bytes32 m6;
5461
        bytes32 m7;
5462
        bytes32 m8;
5463
        /// @solidity memory-safe-assembly
5464
        assembly {
5465
            function writeString(pos, w) {
5466
                let length := 0
5467
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5468
                mstore(pos, length)
5469
                let shift := sub(256, shl(3, length))
5470
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5471
            }
5472
            m0 := mload(0x00)
5473
            m1 := mload(0x20)
5474
            m2 := mload(0x40)
5475
            m3 := mload(0x60)
5476
            m4 := mload(0x80)
5477
            m5 := mload(0xa0)
5478
            m6 := mload(0xc0)
5479
            m7 := mload(0xe0)
5480
            m8 := mload(0x100)
5481
            // Selector of `log(address,string,string,uint256)`.
5482
            mstore(0x00, 0x159f8927)
5483
            mstore(0x20, p0)
5484
            mstore(0x40, 0x80)
5485
            mstore(0x60, 0xc0)
5486
            mstore(0x80, p3)
5487
            writeString(0xa0, p1)
5488
            writeString(0xe0, p2)
5489
        }
5490
        _sendLogPayload(0x1c, 0x104);
5491
        /// @solidity memory-safe-assembly
5492
        assembly {
5493
            mstore(0x00, m0)
5494
            mstore(0x20, m1)
5495
            mstore(0x40, m2)
5496
            mstore(0x60, m3)
5497
            mstore(0x80, m4)
5498
            mstore(0xa0, m5)
5499
            mstore(0xc0, m6)
5500
            mstore(0xe0, m7)
5501
            mstore(0x100, m8)
5502
        }
5503
    }
5504

                            
                        
5505
    function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
5506
        bytes32 m0;
5507
        bytes32 m1;
5508
        bytes32 m2;
5509
        bytes32 m3;
5510
        bytes32 m4;
5511
        bytes32 m5;
5512
        bytes32 m6;
5513
        bytes32 m7;
5514
        bytes32 m8;
5515
        bytes32 m9;
5516
        bytes32 m10;
5517
        /// @solidity memory-safe-assembly
5518
        assembly {
5519
            function writeString(pos, w) {
5520
                let length := 0
5521
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5522
                mstore(pos, length)
5523
                let shift := sub(256, shl(3, length))
5524
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5525
            }
5526
            m0 := mload(0x00)
5527
            m1 := mload(0x20)
5528
            m2 := mload(0x40)
5529
            m3 := mload(0x60)
5530
            m4 := mload(0x80)
5531
            m5 := mload(0xa0)
5532
            m6 := mload(0xc0)
5533
            m7 := mload(0xe0)
5534
            m8 := mload(0x100)
5535
            m9 := mload(0x120)
5536
            m10 := mload(0x140)
5537
            // Selector of `log(address,string,string,string)`.
5538
            mstore(0x00, 0x5d02c50b)
5539
            mstore(0x20, p0)
5540
            mstore(0x40, 0x80)
5541
            mstore(0x60, 0xc0)
5542
            mstore(0x80, 0x100)
5543
            writeString(0xa0, p1)
5544
            writeString(0xe0, p2)
5545
            writeString(0x120, p3)
5546
        }
5547
        _sendLogPayload(0x1c, 0x144);
5548
        /// @solidity memory-safe-assembly
5549
        assembly {
5550
            mstore(0x00, m0)
5551
            mstore(0x20, m1)
5552
            mstore(0x40, m2)
5553
            mstore(0x60, m3)
5554
            mstore(0x80, m4)
5555
            mstore(0xa0, m5)
5556
            mstore(0xc0, m6)
5557
            mstore(0xe0, m7)
5558
            mstore(0x100, m8)
5559
            mstore(0x120, m9)
5560
            mstore(0x140, m10)
5561
        }
5562
    }
5563

                            
                        
5564
    function log(bool p0, address p1, address p2, address p3) internal pure {
5565
        bytes32 m0;
5566
        bytes32 m1;
5567
        bytes32 m2;
5568
        bytes32 m3;
5569
        bytes32 m4;
5570
        /// @solidity memory-safe-assembly
5571
        assembly {
5572
            m0 := mload(0x00)
5573
            m1 := mload(0x20)
5574
            m2 := mload(0x40)
5575
            m3 := mload(0x60)
5576
            m4 := mload(0x80)
5577
            // Selector of `log(bool,address,address,address)`.
5578
            mstore(0x00, 0x1d14d001)
5579
            mstore(0x20, p0)
5580
            mstore(0x40, p1)
5581
            mstore(0x60, p2)
5582
            mstore(0x80, p3)
5583
        }
5584
        _sendLogPayload(0x1c, 0x84);
5585
        /// @solidity memory-safe-assembly
5586
        assembly {
5587
            mstore(0x00, m0)
5588
            mstore(0x20, m1)
5589
            mstore(0x40, m2)
5590
            mstore(0x60, m3)
5591
            mstore(0x80, m4)
5592
        }
5593
    }
5594

                            
                        
5595
    function log(bool p0, address p1, address p2, bool p3) internal pure {
5596
        bytes32 m0;
5597
        bytes32 m1;
5598
        bytes32 m2;
5599
        bytes32 m3;
5600
        bytes32 m4;
5601
        /// @solidity memory-safe-assembly
5602
        assembly {
5603
            m0 := mload(0x00)
5604
            m1 := mload(0x20)
5605
            m2 := mload(0x40)
5606
            m3 := mload(0x60)
5607
            m4 := mload(0x80)
5608
            // Selector of `log(bool,address,address,bool)`.
5609
            mstore(0x00, 0x46600be0)
5610
            mstore(0x20, p0)
5611
            mstore(0x40, p1)
5612
            mstore(0x60, p2)
5613
            mstore(0x80, p3)
5614
        }
5615
        _sendLogPayload(0x1c, 0x84);
5616
        /// @solidity memory-safe-assembly
5617
        assembly {
5618
            mstore(0x00, m0)
5619
            mstore(0x20, m1)
5620
            mstore(0x40, m2)
5621
            mstore(0x60, m3)
5622
            mstore(0x80, m4)
5623
        }
5624
    }
5625

                            
                        
5626
    function log(bool p0, address p1, address p2, uint256 p3) internal pure {
5627
        bytes32 m0;
5628
        bytes32 m1;
5629
        bytes32 m2;
5630
        bytes32 m3;
5631
        bytes32 m4;
5632
        /// @solidity memory-safe-assembly
5633
        assembly {
5634
            m0 := mload(0x00)
5635
            m1 := mload(0x20)
5636
            m2 := mload(0x40)
5637
            m3 := mload(0x60)
5638
            m4 := mload(0x80)
5639
            // Selector of `log(bool,address,address,uint256)`.
5640
            mstore(0x00, 0x0c66d1be)
5641
            mstore(0x20, p0)
5642
            mstore(0x40, p1)
5643
            mstore(0x60, p2)
5644
            mstore(0x80, p3)
5645
        }
5646
        _sendLogPayload(0x1c, 0x84);
5647
        /// @solidity memory-safe-assembly
5648
        assembly {
5649
            mstore(0x00, m0)
5650
            mstore(0x20, m1)
5651
            mstore(0x40, m2)
5652
            mstore(0x60, m3)
5653
            mstore(0x80, m4)
5654
        }
5655
    }
5656

                            
                        
5657
    function log(bool p0, address p1, address p2, bytes32 p3) internal pure {
5658
        bytes32 m0;
5659
        bytes32 m1;
5660
        bytes32 m2;
5661
        bytes32 m3;
5662
        bytes32 m4;
5663
        bytes32 m5;
5664
        bytes32 m6;
5665
        /// @solidity memory-safe-assembly
5666
        assembly {
5667
            function writeString(pos, w) {
5668
                let length := 0
5669
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5670
                mstore(pos, length)
5671
                let shift := sub(256, shl(3, length))
5672
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5673
            }
5674
            m0 := mload(0x00)
5675
            m1 := mload(0x20)
5676
            m2 := mload(0x40)
5677
            m3 := mload(0x60)
5678
            m4 := mload(0x80)
5679
            m5 := mload(0xa0)
5680
            m6 := mload(0xc0)
5681
            // Selector of `log(bool,address,address,string)`.
5682
            mstore(0x00, 0xd812a167)
5683
            mstore(0x20, p0)
5684
            mstore(0x40, p1)
5685
            mstore(0x60, p2)
5686
            mstore(0x80, 0x80)
5687
            writeString(0xa0, p3)
5688
        }
5689
        _sendLogPayload(0x1c, 0xc4);
5690
        /// @solidity memory-safe-assembly
5691
        assembly {
5692
            mstore(0x00, m0)
5693
            mstore(0x20, m1)
5694
            mstore(0x40, m2)
5695
            mstore(0x60, m3)
5696
            mstore(0x80, m4)
5697
            mstore(0xa0, m5)
5698
            mstore(0xc0, m6)
5699
        }
5700
    }
5701

                            
                        
5702
    function log(bool p0, address p1, bool p2, address p3) internal pure {
5703
        bytes32 m0;
5704
        bytes32 m1;
5705
        bytes32 m2;
5706
        bytes32 m3;
5707
        bytes32 m4;
5708
        /// @solidity memory-safe-assembly
5709
        assembly {
5710
            m0 := mload(0x00)
5711
            m1 := mload(0x20)
5712
            m2 := mload(0x40)
5713
            m3 := mload(0x60)
5714
            m4 := mload(0x80)
5715
            // Selector of `log(bool,address,bool,address)`.
5716
            mstore(0x00, 0x1c41a336)
5717
            mstore(0x20, p0)
5718
            mstore(0x40, p1)
5719
            mstore(0x60, p2)
5720
            mstore(0x80, p3)
5721
        }
5722
        _sendLogPayload(0x1c, 0x84);
5723
        /// @solidity memory-safe-assembly
5724
        assembly {
5725
            mstore(0x00, m0)
5726
            mstore(0x20, m1)
5727
            mstore(0x40, m2)
5728
            mstore(0x60, m3)
5729
            mstore(0x80, m4)
5730
        }
5731
    }
5732

                            
                        
5733
    function log(bool p0, address p1, bool p2, bool p3) internal pure {
5734
        bytes32 m0;
5735
        bytes32 m1;
5736
        bytes32 m2;
5737
        bytes32 m3;
5738
        bytes32 m4;
5739
        /// @solidity memory-safe-assembly
5740
        assembly {
5741
            m0 := mload(0x00)
5742
            m1 := mload(0x20)
5743
            m2 := mload(0x40)
5744
            m3 := mload(0x60)
5745
            m4 := mload(0x80)
5746
            // Selector of `log(bool,address,bool,bool)`.
5747
            mstore(0x00, 0x6a9c478b)
5748
            mstore(0x20, p0)
5749
            mstore(0x40, p1)
5750
            mstore(0x60, p2)
5751
            mstore(0x80, p3)
5752
        }
5753
        _sendLogPayload(0x1c, 0x84);
5754
        /// @solidity memory-safe-assembly
5755
        assembly {
5756
            mstore(0x00, m0)
5757
            mstore(0x20, m1)
5758
            mstore(0x40, m2)
5759
            mstore(0x60, m3)
5760
            mstore(0x80, m4)
5761
        }
5762
    }
5763

                            
                        
5764
    function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
5765
        bytes32 m0;
5766
        bytes32 m1;
5767
        bytes32 m2;
5768
        bytes32 m3;
5769
        bytes32 m4;
5770
        /// @solidity memory-safe-assembly
5771
        assembly {
5772
            m0 := mload(0x00)
5773
            m1 := mload(0x20)
5774
            m2 := mload(0x40)
5775
            m3 := mload(0x60)
5776
            m4 := mload(0x80)
5777
            // Selector of `log(bool,address,bool,uint256)`.
5778
            mstore(0x00, 0x07831502)
5779
            mstore(0x20, p0)
5780
            mstore(0x40, p1)
5781
            mstore(0x60, p2)
5782
            mstore(0x80, p3)
5783
        }
5784
        _sendLogPayload(0x1c, 0x84);
5785
        /// @solidity memory-safe-assembly
5786
        assembly {
5787
            mstore(0x00, m0)
5788
            mstore(0x20, m1)
5789
            mstore(0x40, m2)
5790
            mstore(0x60, m3)
5791
            mstore(0x80, m4)
5792
        }
5793
    }
5794

                            
                        
5795
    function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {
5796
        bytes32 m0;
5797
        bytes32 m1;
5798
        bytes32 m2;
5799
        bytes32 m3;
5800
        bytes32 m4;
5801
        bytes32 m5;
5802
        bytes32 m6;
5803
        /// @solidity memory-safe-assembly
5804
        assembly {
5805
            function writeString(pos, w) {
5806
                let length := 0
5807
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5808
                mstore(pos, length)
5809
                let shift := sub(256, shl(3, length))
5810
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5811
            }
5812
            m0 := mload(0x00)
5813
            m1 := mload(0x20)
5814
            m2 := mload(0x40)
5815
            m3 := mload(0x60)
5816
            m4 := mload(0x80)
5817
            m5 := mload(0xa0)
5818
            m6 := mload(0xc0)
5819
            // Selector of `log(bool,address,bool,string)`.
5820
            mstore(0x00, 0x4a66cb34)
5821
            mstore(0x20, p0)
5822
            mstore(0x40, p1)
5823
            mstore(0x60, p2)
5824
            mstore(0x80, 0x80)
5825
            writeString(0xa0, p3)
5826
        }
5827
        _sendLogPayload(0x1c, 0xc4);
5828
        /// @solidity memory-safe-assembly
5829
        assembly {
5830
            mstore(0x00, m0)
5831
            mstore(0x20, m1)
5832
            mstore(0x40, m2)
5833
            mstore(0x60, m3)
5834
            mstore(0x80, m4)
5835
            mstore(0xa0, m5)
5836
            mstore(0xc0, m6)
5837
        }
5838
    }
5839

                            
                        
5840
    function log(bool p0, address p1, uint256 p2, address p3) internal pure {
5841
        bytes32 m0;
5842
        bytes32 m1;
5843
        bytes32 m2;
5844
        bytes32 m3;
5845
        bytes32 m4;
5846
        /// @solidity memory-safe-assembly
5847
        assembly {
5848
            m0 := mload(0x00)
5849
            m1 := mload(0x20)
5850
            m2 := mload(0x40)
5851
            m3 := mload(0x60)
5852
            m4 := mload(0x80)
5853
            // Selector of `log(bool,address,uint256,address)`.
5854
            mstore(0x00, 0x136b05dd)
5855
            mstore(0x20, p0)
5856
            mstore(0x40, p1)
5857
            mstore(0x60, p2)
5858
            mstore(0x80, p3)
5859
        }
5860
        _sendLogPayload(0x1c, 0x84);
5861
        /// @solidity memory-safe-assembly
5862
        assembly {
5863
            mstore(0x00, m0)
5864
            mstore(0x20, m1)
5865
            mstore(0x40, m2)
5866
            mstore(0x60, m3)
5867
            mstore(0x80, m4)
5868
        }
5869
    }
5870

                            
                        
5871
    function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
5872
        bytes32 m0;
5873
        bytes32 m1;
5874
        bytes32 m2;
5875
        bytes32 m3;
5876
        bytes32 m4;
5877
        /// @solidity memory-safe-assembly
5878
        assembly {
5879
            m0 := mload(0x00)
5880
            m1 := mload(0x20)
5881
            m2 := mload(0x40)
5882
            m3 := mload(0x60)
5883
            m4 := mload(0x80)
5884
            // Selector of `log(bool,address,uint256,bool)`.
5885
            mstore(0x00, 0xd6019f1c)
5886
            mstore(0x20, p0)
5887
            mstore(0x40, p1)
5888
            mstore(0x60, p2)
5889
            mstore(0x80, p3)
5890
        }
5891
        _sendLogPayload(0x1c, 0x84);
5892
        /// @solidity memory-safe-assembly
5893
        assembly {
5894
            mstore(0x00, m0)
5895
            mstore(0x20, m1)
5896
            mstore(0x40, m2)
5897
            mstore(0x60, m3)
5898
            mstore(0x80, m4)
5899
        }
5900
    }
5901

                            
                        
5902
    function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
5903
        bytes32 m0;
5904
        bytes32 m1;
5905
        bytes32 m2;
5906
        bytes32 m3;
5907
        bytes32 m4;
5908
        /// @solidity memory-safe-assembly
5909
        assembly {
5910
            m0 := mload(0x00)
5911
            m1 := mload(0x20)
5912
            m2 := mload(0x40)
5913
            m3 := mload(0x60)
5914
            m4 := mload(0x80)
5915
            // Selector of `log(bool,address,uint256,uint256)`.
5916
            mstore(0x00, 0x7bf181a1)
5917
            mstore(0x20, p0)
5918
            mstore(0x40, p1)
5919
            mstore(0x60, p2)
5920
            mstore(0x80, p3)
5921
        }
5922
        _sendLogPayload(0x1c, 0x84);
5923
        /// @solidity memory-safe-assembly
5924
        assembly {
5925
            mstore(0x00, m0)
5926
            mstore(0x20, m1)
5927
            mstore(0x40, m2)
5928
            mstore(0x60, m3)
5929
            mstore(0x80, m4)
5930
        }
5931
    }
5932

                            
                        
5933
    function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {
5934
        bytes32 m0;
5935
        bytes32 m1;
5936
        bytes32 m2;
5937
        bytes32 m3;
5938
        bytes32 m4;
5939
        bytes32 m5;
5940
        bytes32 m6;
5941
        /// @solidity memory-safe-assembly
5942
        assembly {
5943
            function writeString(pos, w) {
5944
                let length := 0
5945
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5946
                mstore(pos, length)
5947
                let shift := sub(256, shl(3, length))
5948
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5949
            }
5950
            m0 := mload(0x00)
5951
            m1 := mload(0x20)
5952
            m2 := mload(0x40)
5953
            m3 := mload(0x60)
5954
            m4 := mload(0x80)
5955
            m5 := mload(0xa0)
5956
            m6 := mload(0xc0)
5957
            // Selector of `log(bool,address,uint256,string)`.
5958
            mstore(0x00, 0x51f09ff8)
5959
            mstore(0x20, p0)
5960
            mstore(0x40, p1)
5961
            mstore(0x60, p2)
5962
            mstore(0x80, 0x80)
5963
            writeString(0xa0, p3)
5964
        }
5965
        _sendLogPayload(0x1c, 0xc4);
5966
        /// @solidity memory-safe-assembly
5967
        assembly {
5968
            mstore(0x00, m0)
5969
            mstore(0x20, m1)
5970
            mstore(0x40, m2)
5971
            mstore(0x60, m3)
5972
            mstore(0x80, m4)
5973
            mstore(0xa0, m5)
5974
            mstore(0xc0, m6)
5975
        }
5976
    }
5977

                            
                        
5978
    function log(bool p0, address p1, bytes32 p2, address p3) internal pure {
5979
        bytes32 m0;
5980
        bytes32 m1;
5981
        bytes32 m2;
5982
        bytes32 m3;
5983
        bytes32 m4;
5984
        bytes32 m5;
5985
        bytes32 m6;
5986
        /// @solidity memory-safe-assembly
5987
        assembly {
5988
            function writeString(pos, w) {
5989
                let length := 0
5990
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
5991
                mstore(pos, length)
5992
                let shift := sub(256, shl(3, length))
5993
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
5994
            }
5995
            m0 := mload(0x00)
5996
            m1 := mload(0x20)
5997
            m2 := mload(0x40)
5998
            m3 := mload(0x60)
5999
            m4 := mload(0x80)
6000
            m5 := mload(0xa0)
6001
            m6 := mload(0xc0)
6002
            // Selector of `log(bool,address,string,address)`.
6003
            mstore(0x00, 0x6f7c603e)
6004
            mstore(0x20, p0)
6005
            mstore(0x40, p1)
6006
            mstore(0x60, 0x80)
6007
            mstore(0x80, p3)
6008
            writeString(0xa0, p2)
6009
        }
6010
        _sendLogPayload(0x1c, 0xc4);
6011
        /// @solidity memory-safe-assembly
6012
        assembly {
6013
            mstore(0x00, m0)
6014
            mstore(0x20, m1)
6015
            mstore(0x40, m2)
6016
            mstore(0x60, m3)
6017
            mstore(0x80, m4)
6018
            mstore(0xa0, m5)
6019
            mstore(0xc0, m6)
6020
        }
6021
    }
6022

                            
                        
6023
    function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {
6024
        bytes32 m0;
6025
        bytes32 m1;
6026
        bytes32 m2;
6027
        bytes32 m3;
6028
        bytes32 m4;
6029
        bytes32 m5;
6030
        bytes32 m6;
6031
        /// @solidity memory-safe-assembly
6032
        assembly {
6033
            function writeString(pos, w) {
6034
                let length := 0
6035
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6036
                mstore(pos, length)
6037
                let shift := sub(256, shl(3, length))
6038
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6039
            }
6040
            m0 := mload(0x00)
6041
            m1 := mload(0x20)
6042
            m2 := mload(0x40)
6043
            m3 := mload(0x60)
6044
            m4 := mload(0x80)
6045
            m5 := mload(0xa0)
6046
            m6 := mload(0xc0)
6047
            // Selector of `log(bool,address,string,bool)`.
6048
            mstore(0x00, 0xe2bfd60b)
6049
            mstore(0x20, p0)
6050
            mstore(0x40, p1)
6051
            mstore(0x60, 0x80)
6052
            mstore(0x80, p3)
6053
            writeString(0xa0, p2)
6054
        }
6055
        _sendLogPayload(0x1c, 0xc4);
6056
        /// @solidity memory-safe-assembly
6057
        assembly {
6058
            mstore(0x00, m0)
6059
            mstore(0x20, m1)
6060
            mstore(0x40, m2)
6061
            mstore(0x60, m3)
6062
            mstore(0x80, m4)
6063
            mstore(0xa0, m5)
6064
            mstore(0xc0, m6)
6065
        }
6066
    }
6067

                            
                        
6068
    function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {
6069
        bytes32 m0;
6070
        bytes32 m1;
6071
        bytes32 m2;
6072
        bytes32 m3;
6073
        bytes32 m4;
6074
        bytes32 m5;
6075
        bytes32 m6;
6076
        /// @solidity memory-safe-assembly
6077
        assembly {
6078
            function writeString(pos, w) {
6079
                let length := 0
6080
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6081
                mstore(pos, length)
6082
                let shift := sub(256, shl(3, length))
6083
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6084
            }
6085
            m0 := mload(0x00)
6086
            m1 := mload(0x20)
6087
            m2 := mload(0x40)
6088
            m3 := mload(0x60)
6089
            m4 := mload(0x80)
6090
            m5 := mload(0xa0)
6091
            m6 := mload(0xc0)
6092
            // Selector of `log(bool,address,string,uint256)`.
6093
            mstore(0x00, 0xc21f64c7)
6094
            mstore(0x20, p0)
6095
            mstore(0x40, p1)
6096
            mstore(0x60, 0x80)
6097
            mstore(0x80, p3)
6098
            writeString(0xa0, p2)
6099
        }
6100
        _sendLogPayload(0x1c, 0xc4);
6101
        /// @solidity memory-safe-assembly
6102
        assembly {
6103
            mstore(0x00, m0)
6104
            mstore(0x20, m1)
6105
            mstore(0x40, m2)
6106
            mstore(0x60, m3)
6107
            mstore(0x80, m4)
6108
            mstore(0xa0, m5)
6109
            mstore(0xc0, m6)
6110
        }
6111
    }
6112

                            
                        
6113
    function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {
6114
        bytes32 m0;
6115
        bytes32 m1;
6116
        bytes32 m2;
6117
        bytes32 m3;
6118
        bytes32 m4;
6119
        bytes32 m5;
6120
        bytes32 m6;
6121
        bytes32 m7;
6122
        bytes32 m8;
6123
        /// @solidity memory-safe-assembly
6124
        assembly {
6125
            function writeString(pos, w) {
6126
                let length := 0
6127
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6128
                mstore(pos, length)
6129
                let shift := sub(256, shl(3, length))
6130
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6131
            }
6132
            m0 := mload(0x00)
6133
            m1 := mload(0x20)
6134
            m2 := mload(0x40)
6135
            m3 := mload(0x60)
6136
            m4 := mload(0x80)
6137
            m5 := mload(0xa0)
6138
            m6 := mload(0xc0)
6139
            m7 := mload(0xe0)
6140
            m8 := mload(0x100)
6141
            // Selector of `log(bool,address,string,string)`.
6142
            mstore(0x00, 0xa73c1db6)
6143
            mstore(0x20, p0)
6144
            mstore(0x40, p1)
6145
            mstore(0x60, 0x80)
6146
            mstore(0x80, 0xc0)
6147
            writeString(0xa0, p2)
6148
            writeString(0xe0, p3)
6149
        }
6150
        _sendLogPayload(0x1c, 0x104);
6151
        /// @solidity memory-safe-assembly
6152
        assembly {
6153
            mstore(0x00, m0)
6154
            mstore(0x20, m1)
6155
            mstore(0x40, m2)
6156
            mstore(0x60, m3)
6157
            mstore(0x80, m4)
6158
            mstore(0xa0, m5)
6159
            mstore(0xc0, m6)
6160
            mstore(0xe0, m7)
6161
            mstore(0x100, m8)
6162
        }
6163
    }
6164

                            
                        
6165
    function log(bool p0, bool p1, address p2, address p3) internal pure {
6166
        bytes32 m0;
6167
        bytes32 m1;
6168
        bytes32 m2;
6169
        bytes32 m3;
6170
        bytes32 m4;
6171
        /// @solidity memory-safe-assembly
6172
        assembly {
6173
            m0 := mload(0x00)
6174
            m1 := mload(0x20)
6175
            m2 := mload(0x40)
6176
            m3 := mload(0x60)
6177
            m4 := mload(0x80)
6178
            // Selector of `log(bool,bool,address,address)`.
6179
            mstore(0x00, 0xf4880ea4)
6180
            mstore(0x20, p0)
6181
            mstore(0x40, p1)
6182
            mstore(0x60, p2)
6183
            mstore(0x80, p3)
6184
        }
6185
        _sendLogPayload(0x1c, 0x84);
6186
        /// @solidity memory-safe-assembly
6187
        assembly {
6188
            mstore(0x00, m0)
6189
            mstore(0x20, m1)
6190
            mstore(0x40, m2)
6191
            mstore(0x60, m3)
6192
            mstore(0x80, m4)
6193
        }
6194
    }
6195

                            
                        
6196
    function log(bool p0, bool p1, address p2, bool p3) internal pure {
6197
        bytes32 m0;
6198
        bytes32 m1;
6199
        bytes32 m2;
6200
        bytes32 m3;
6201
        bytes32 m4;
6202
        /// @solidity memory-safe-assembly
6203
        assembly {
6204
            m0 := mload(0x00)
6205
            m1 := mload(0x20)
6206
            m2 := mload(0x40)
6207
            m3 := mload(0x60)
6208
            m4 := mload(0x80)
6209
            // Selector of `log(bool,bool,address,bool)`.
6210
            mstore(0x00, 0xc0a302d8)
6211
            mstore(0x20, p0)
6212
            mstore(0x40, p1)
6213
            mstore(0x60, p2)
6214
            mstore(0x80, p3)
6215
        }
6216
        _sendLogPayload(0x1c, 0x84);
6217
        /// @solidity memory-safe-assembly
6218
        assembly {
6219
            mstore(0x00, m0)
6220
            mstore(0x20, m1)
6221
            mstore(0x40, m2)
6222
            mstore(0x60, m3)
6223
            mstore(0x80, m4)
6224
        }
6225
    }
6226

                            
                        
6227
    function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
6228
        bytes32 m0;
6229
        bytes32 m1;
6230
        bytes32 m2;
6231
        bytes32 m3;
6232
        bytes32 m4;
6233
        /// @solidity memory-safe-assembly
6234
        assembly {
6235
            m0 := mload(0x00)
6236
            m1 := mload(0x20)
6237
            m2 := mload(0x40)
6238
            m3 := mload(0x60)
6239
            m4 := mload(0x80)
6240
            // Selector of `log(bool,bool,address,uint256)`.
6241
            mstore(0x00, 0x4c123d57)
6242
            mstore(0x20, p0)
6243
            mstore(0x40, p1)
6244
            mstore(0x60, p2)
6245
            mstore(0x80, p3)
6246
        }
6247
        _sendLogPayload(0x1c, 0x84);
6248
        /// @solidity memory-safe-assembly
6249
        assembly {
6250
            mstore(0x00, m0)
6251
            mstore(0x20, m1)
6252
            mstore(0x40, m2)
6253
            mstore(0x60, m3)
6254
            mstore(0x80, m4)
6255
        }
6256
    }
6257

                            
                        
6258
    function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {
6259
        bytes32 m0;
6260
        bytes32 m1;
6261
        bytes32 m2;
6262
        bytes32 m3;
6263
        bytes32 m4;
6264
        bytes32 m5;
6265
        bytes32 m6;
6266
        /// @solidity memory-safe-assembly
6267
        assembly {
6268
            function writeString(pos, w) {
6269
                let length := 0
6270
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6271
                mstore(pos, length)
6272
                let shift := sub(256, shl(3, length))
6273
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6274
            }
6275
            m0 := mload(0x00)
6276
            m1 := mload(0x20)
6277
            m2 := mload(0x40)
6278
            m3 := mload(0x60)
6279
            m4 := mload(0x80)
6280
            m5 := mload(0xa0)
6281
            m6 := mload(0xc0)
6282
            // Selector of `log(bool,bool,address,string)`.
6283
            mstore(0x00, 0xa0a47963)
6284
            mstore(0x20, p0)
6285
            mstore(0x40, p1)
6286
            mstore(0x60, p2)
6287
            mstore(0x80, 0x80)
6288
            writeString(0xa0, p3)
6289
        }
6290
        _sendLogPayload(0x1c, 0xc4);
6291
        /// @solidity memory-safe-assembly
6292
        assembly {
6293
            mstore(0x00, m0)
6294
            mstore(0x20, m1)
6295
            mstore(0x40, m2)
6296
            mstore(0x60, m3)
6297
            mstore(0x80, m4)
6298
            mstore(0xa0, m5)
6299
            mstore(0xc0, m6)
6300
        }
6301
    }
6302

                            
                        
6303
    function log(bool p0, bool p1, bool p2, address p3) internal pure {
6304
        bytes32 m0;
6305
        bytes32 m1;
6306
        bytes32 m2;
6307
        bytes32 m3;
6308
        bytes32 m4;
6309
        /// @solidity memory-safe-assembly
6310
        assembly {
6311
            m0 := mload(0x00)
6312
            m1 := mload(0x20)
6313
            m2 := mload(0x40)
6314
            m3 := mload(0x60)
6315
            m4 := mload(0x80)
6316
            // Selector of `log(bool,bool,bool,address)`.
6317
            mstore(0x00, 0x8c329b1a)
6318
            mstore(0x20, p0)
6319
            mstore(0x40, p1)
6320
            mstore(0x60, p2)
6321
            mstore(0x80, p3)
6322
        }
6323
        _sendLogPayload(0x1c, 0x84);
6324
        /// @solidity memory-safe-assembly
6325
        assembly {
6326
            mstore(0x00, m0)
6327
            mstore(0x20, m1)
6328
            mstore(0x40, m2)
6329
            mstore(0x60, m3)
6330
            mstore(0x80, m4)
6331
        }
6332
    }
6333

                            
                        
6334
    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
6335
        bytes32 m0;
6336
        bytes32 m1;
6337
        bytes32 m2;
6338
        bytes32 m3;
6339
        bytes32 m4;
6340
        /// @solidity memory-safe-assembly
6341
        assembly {
6342
            m0 := mload(0x00)
6343
            m1 := mload(0x20)
6344
            m2 := mload(0x40)
6345
            m3 := mload(0x60)
6346
            m4 := mload(0x80)
6347
            // Selector of `log(bool,bool,bool,bool)`.
6348
            mstore(0x00, 0x3b2a5ce0)
6349
            mstore(0x20, p0)
6350
            mstore(0x40, p1)
6351
            mstore(0x60, p2)
6352
            mstore(0x80, p3)
6353
        }
6354
        _sendLogPayload(0x1c, 0x84);
6355
        /// @solidity memory-safe-assembly
6356
        assembly {
6357
            mstore(0x00, m0)
6358
            mstore(0x20, m1)
6359
            mstore(0x40, m2)
6360
            mstore(0x60, m3)
6361
            mstore(0x80, m4)
6362
        }
6363
    }
6364

                            
                        
6365
    function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
6366
        bytes32 m0;
6367
        bytes32 m1;
6368
        bytes32 m2;
6369
        bytes32 m3;
6370
        bytes32 m4;
6371
        /// @solidity memory-safe-assembly
6372
        assembly {
6373
            m0 := mload(0x00)
6374
            m1 := mload(0x20)
6375
            m2 := mload(0x40)
6376
            m3 := mload(0x60)
6377
            m4 := mload(0x80)
6378
            // Selector of `log(bool,bool,bool,uint256)`.
6379
            mstore(0x00, 0x6d7045c1)
6380
            mstore(0x20, p0)
6381
            mstore(0x40, p1)
6382
            mstore(0x60, p2)
6383
            mstore(0x80, p3)
6384
        }
6385
        _sendLogPayload(0x1c, 0x84);
6386
        /// @solidity memory-safe-assembly
6387
        assembly {
6388
            mstore(0x00, m0)
6389
            mstore(0x20, m1)
6390
            mstore(0x40, m2)
6391
            mstore(0x60, m3)
6392
            mstore(0x80, m4)
6393
        }
6394
    }
6395

                            
                        
6396
    function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {
6397
        bytes32 m0;
6398
        bytes32 m1;
6399
        bytes32 m2;
6400
        bytes32 m3;
6401
        bytes32 m4;
6402
        bytes32 m5;
6403
        bytes32 m6;
6404
        /// @solidity memory-safe-assembly
6405
        assembly {
6406
            function writeString(pos, w) {
6407
                let length := 0
6408
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6409
                mstore(pos, length)
6410
                let shift := sub(256, shl(3, length))
6411
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6412
            }
6413
            m0 := mload(0x00)
6414
            m1 := mload(0x20)
6415
            m2 := mload(0x40)
6416
            m3 := mload(0x60)
6417
            m4 := mload(0x80)
6418
            m5 := mload(0xa0)
6419
            m6 := mload(0xc0)
6420
            // Selector of `log(bool,bool,bool,string)`.
6421
            mstore(0x00, 0x2ae408d4)
6422
            mstore(0x20, p0)
6423
            mstore(0x40, p1)
6424
            mstore(0x60, p2)
6425
            mstore(0x80, 0x80)
6426
            writeString(0xa0, p3)
6427
        }
6428
        _sendLogPayload(0x1c, 0xc4);
6429
        /// @solidity memory-safe-assembly
6430
        assembly {
6431
            mstore(0x00, m0)
6432
            mstore(0x20, m1)
6433
            mstore(0x40, m2)
6434
            mstore(0x60, m3)
6435
            mstore(0x80, m4)
6436
            mstore(0xa0, m5)
6437
            mstore(0xc0, m6)
6438
        }
6439
    }
6440

                            
                        
6441
    function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
6442
        bytes32 m0;
6443
        bytes32 m1;
6444
        bytes32 m2;
6445
        bytes32 m3;
6446
        bytes32 m4;
6447
        /// @solidity memory-safe-assembly
6448
        assembly {
6449
            m0 := mload(0x00)
6450
            m1 := mload(0x20)
6451
            m2 := mload(0x40)
6452
            m3 := mload(0x60)
6453
            m4 := mload(0x80)
6454
            // Selector of `log(bool,bool,uint256,address)`.
6455
            mstore(0x00, 0x54a7a9a0)
6456
            mstore(0x20, p0)
6457
            mstore(0x40, p1)
6458
            mstore(0x60, p2)
6459
            mstore(0x80, p3)
6460
        }
6461
        _sendLogPayload(0x1c, 0x84);
6462
        /// @solidity memory-safe-assembly
6463
        assembly {
6464
            mstore(0x00, m0)
6465
            mstore(0x20, m1)
6466
            mstore(0x40, m2)
6467
            mstore(0x60, m3)
6468
            mstore(0x80, m4)
6469
        }
6470
    }
6471

                            
                        
6472
    function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
6473
        bytes32 m0;
6474
        bytes32 m1;
6475
        bytes32 m2;
6476
        bytes32 m3;
6477
        bytes32 m4;
6478
        /// @solidity memory-safe-assembly
6479
        assembly {
6480
            m0 := mload(0x00)
6481
            m1 := mload(0x20)
6482
            m2 := mload(0x40)
6483
            m3 := mload(0x60)
6484
            m4 := mload(0x80)
6485
            // Selector of `log(bool,bool,uint256,bool)`.
6486
            mstore(0x00, 0x619e4d0e)
6487
            mstore(0x20, p0)
6488
            mstore(0x40, p1)
6489
            mstore(0x60, p2)
6490
            mstore(0x80, p3)
6491
        }
6492
        _sendLogPayload(0x1c, 0x84);
6493
        /// @solidity memory-safe-assembly
6494
        assembly {
6495
            mstore(0x00, m0)
6496
            mstore(0x20, m1)
6497
            mstore(0x40, m2)
6498
            mstore(0x60, m3)
6499
            mstore(0x80, m4)
6500
        }
6501
    }
6502

                            
                        
6503
    function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
6504
        bytes32 m0;
6505
        bytes32 m1;
6506
        bytes32 m2;
6507
        bytes32 m3;
6508
        bytes32 m4;
6509
        /// @solidity memory-safe-assembly
6510
        assembly {
6511
            m0 := mload(0x00)
6512
            m1 := mload(0x20)
6513
            m2 := mload(0x40)
6514
            m3 := mload(0x60)
6515
            m4 := mload(0x80)
6516
            // Selector of `log(bool,bool,uint256,uint256)`.
6517
            mstore(0x00, 0x0bb00eab)
6518
            mstore(0x20, p0)
6519
            mstore(0x40, p1)
6520
            mstore(0x60, p2)
6521
            mstore(0x80, p3)
6522
        }
6523
        _sendLogPayload(0x1c, 0x84);
6524
        /// @solidity memory-safe-assembly
6525
        assembly {
6526
            mstore(0x00, m0)
6527
            mstore(0x20, m1)
6528
            mstore(0x40, m2)
6529
            mstore(0x60, m3)
6530
            mstore(0x80, m4)
6531
        }
6532
    }
6533

                            
                        
6534
    function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {
6535
        bytes32 m0;
6536
        bytes32 m1;
6537
        bytes32 m2;
6538
        bytes32 m3;
6539
        bytes32 m4;
6540
        bytes32 m5;
6541
        bytes32 m6;
6542
        /// @solidity memory-safe-assembly
6543
        assembly {
6544
            function writeString(pos, w) {
6545
                let length := 0
6546
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6547
                mstore(pos, length)
6548
                let shift := sub(256, shl(3, length))
6549
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6550
            }
6551
            m0 := mload(0x00)
6552
            m1 := mload(0x20)
6553
            m2 := mload(0x40)
6554
            m3 := mload(0x60)
6555
            m4 := mload(0x80)
6556
            m5 := mload(0xa0)
6557
            m6 := mload(0xc0)
6558
            // Selector of `log(bool,bool,uint256,string)`.
6559
            mstore(0x00, 0x7dd4d0e0)
6560
            mstore(0x20, p0)
6561
            mstore(0x40, p1)
6562
            mstore(0x60, p2)
6563
            mstore(0x80, 0x80)
6564
            writeString(0xa0, p3)
6565
        }
6566
        _sendLogPayload(0x1c, 0xc4);
6567
        /// @solidity memory-safe-assembly
6568
        assembly {
6569
            mstore(0x00, m0)
6570
            mstore(0x20, m1)
6571
            mstore(0x40, m2)
6572
            mstore(0x60, m3)
6573
            mstore(0x80, m4)
6574
            mstore(0xa0, m5)
6575
            mstore(0xc0, m6)
6576
        }
6577
    }
6578

                            
                        
6579
    function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {
6580
        bytes32 m0;
6581
        bytes32 m1;
6582
        bytes32 m2;
6583
        bytes32 m3;
6584
        bytes32 m4;
6585
        bytes32 m5;
6586
        bytes32 m6;
6587
        /// @solidity memory-safe-assembly
6588
        assembly {
6589
            function writeString(pos, w) {
6590
                let length := 0
6591
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6592
                mstore(pos, length)
6593
                let shift := sub(256, shl(3, length))
6594
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6595
            }
6596
            m0 := mload(0x00)
6597
            m1 := mload(0x20)
6598
            m2 := mload(0x40)
6599
            m3 := mload(0x60)
6600
            m4 := mload(0x80)
6601
            m5 := mload(0xa0)
6602
            m6 := mload(0xc0)
6603
            // Selector of `log(bool,bool,string,address)`.
6604
            mstore(0x00, 0xf9ad2b89)
6605
            mstore(0x20, p0)
6606
            mstore(0x40, p1)
6607
            mstore(0x60, 0x80)
6608
            mstore(0x80, p3)
6609
            writeString(0xa0, p2)
6610
        }
6611
        _sendLogPayload(0x1c, 0xc4);
6612
        /// @solidity memory-safe-assembly
6613
        assembly {
6614
            mstore(0x00, m0)
6615
            mstore(0x20, m1)
6616
            mstore(0x40, m2)
6617
            mstore(0x60, m3)
6618
            mstore(0x80, m4)
6619
            mstore(0xa0, m5)
6620
            mstore(0xc0, m6)
6621
        }
6622
    }
6623

                            
                        
6624
    function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {
6625
        bytes32 m0;
6626
        bytes32 m1;
6627
        bytes32 m2;
6628
        bytes32 m3;
6629
        bytes32 m4;
6630
        bytes32 m5;
6631
        bytes32 m6;
6632
        /// @solidity memory-safe-assembly
6633
        assembly {
6634
            function writeString(pos, w) {
6635
                let length := 0
6636
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6637
                mstore(pos, length)
6638
                let shift := sub(256, shl(3, length))
6639
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6640
            }
6641
            m0 := mload(0x00)
6642
            m1 := mload(0x20)
6643
            m2 := mload(0x40)
6644
            m3 := mload(0x60)
6645
            m4 := mload(0x80)
6646
            m5 := mload(0xa0)
6647
            m6 := mload(0xc0)
6648
            // Selector of `log(bool,bool,string,bool)`.
6649
            mstore(0x00, 0xb857163a)
6650
            mstore(0x20, p0)
6651
            mstore(0x40, p1)
6652
            mstore(0x60, 0x80)
6653
            mstore(0x80, p3)
6654
            writeString(0xa0, p2)
6655
        }
6656
        _sendLogPayload(0x1c, 0xc4);
6657
        /// @solidity memory-safe-assembly
6658
        assembly {
6659
            mstore(0x00, m0)
6660
            mstore(0x20, m1)
6661
            mstore(0x40, m2)
6662
            mstore(0x60, m3)
6663
            mstore(0x80, m4)
6664
            mstore(0xa0, m5)
6665
            mstore(0xc0, m6)
6666
        }
6667
    }
6668

                            
                        
6669
    function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {
6670
        bytes32 m0;
6671
        bytes32 m1;
6672
        bytes32 m2;
6673
        bytes32 m3;
6674
        bytes32 m4;
6675
        bytes32 m5;
6676
        bytes32 m6;
6677
        /// @solidity memory-safe-assembly
6678
        assembly {
6679
            function writeString(pos, w) {
6680
                let length := 0
6681
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6682
                mstore(pos, length)
6683
                let shift := sub(256, shl(3, length))
6684
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6685
            }
6686
            m0 := mload(0x00)
6687
            m1 := mload(0x20)
6688
            m2 := mload(0x40)
6689
            m3 := mload(0x60)
6690
            m4 := mload(0x80)
6691
            m5 := mload(0xa0)
6692
            m6 := mload(0xc0)
6693
            // Selector of `log(bool,bool,string,uint256)`.
6694
            mstore(0x00, 0xe3a9ca2f)
6695
            mstore(0x20, p0)
6696
            mstore(0x40, p1)
6697
            mstore(0x60, 0x80)
6698
            mstore(0x80, p3)
6699
            writeString(0xa0, p2)
6700
        }
6701
        _sendLogPayload(0x1c, 0xc4);
6702
        /// @solidity memory-safe-assembly
6703
        assembly {
6704
            mstore(0x00, m0)
6705
            mstore(0x20, m1)
6706
            mstore(0x40, m2)
6707
            mstore(0x60, m3)
6708
            mstore(0x80, m4)
6709
            mstore(0xa0, m5)
6710
            mstore(0xc0, m6)
6711
        }
6712
    }
6713

                            
                        
6714
    function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
6715
        bytes32 m0;
6716
        bytes32 m1;
6717
        bytes32 m2;
6718
        bytes32 m3;
6719
        bytes32 m4;
6720
        bytes32 m5;
6721
        bytes32 m6;
6722
        bytes32 m7;
6723
        bytes32 m8;
6724
        /// @solidity memory-safe-assembly
6725
        assembly {
6726
            function writeString(pos, w) {
6727
                let length := 0
6728
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6729
                mstore(pos, length)
6730
                let shift := sub(256, shl(3, length))
6731
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6732
            }
6733
            m0 := mload(0x00)
6734
            m1 := mload(0x20)
6735
            m2 := mload(0x40)
6736
            m3 := mload(0x60)
6737
            m4 := mload(0x80)
6738
            m5 := mload(0xa0)
6739
            m6 := mload(0xc0)
6740
            m7 := mload(0xe0)
6741
            m8 := mload(0x100)
6742
            // Selector of `log(bool,bool,string,string)`.
6743
            mstore(0x00, 0x6d1e8751)
6744
            mstore(0x20, p0)
6745
            mstore(0x40, p1)
6746
            mstore(0x60, 0x80)
6747
            mstore(0x80, 0xc0)
6748
            writeString(0xa0, p2)
6749
            writeString(0xe0, p3)
6750
        }
6751
        _sendLogPayload(0x1c, 0x104);
6752
        /// @solidity memory-safe-assembly
6753
        assembly {
6754
            mstore(0x00, m0)
6755
            mstore(0x20, m1)
6756
            mstore(0x40, m2)
6757
            mstore(0x60, m3)
6758
            mstore(0x80, m4)
6759
            mstore(0xa0, m5)
6760
            mstore(0xc0, m6)
6761
            mstore(0xe0, m7)
6762
            mstore(0x100, m8)
6763
        }
6764
    }
6765

                            
                        
6766
    function log(bool p0, uint256 p1, address p2, address p3) internal pure {
6767
        bytes32 m0;
6768
        bytes32 m1;
6769
        bytes32 m2;
6770
        bytes32 m3;
6771
        bytes32 m4;
6772
        /// @solidity memory-safe-assembly
6773
        assembly {
6774
            m0 := mload(0x00)
6775
            m1 := mload(0x20)
6776
            m2 := mload(0x40)
6777
            m3 := mload(0x60)
6778
            m4 := mload(0x80)
6779
            // Selector of `log(bool,uint256,address,address)`.
6780
            mstore(0x00, 0x26f560a8)
6781
            mstore(0x20, p0)
6782
            mstore(0x40, p1)
6783
            mstore(0x60, p2)
6784
            mstore(0x80, p3)
6785
        }
6786
        _sendLogPayload(0x1c, 0x84);
6787
        /// @solidity memory-safe-assembly
6788
        assembly {
6789
            mstore(0x00, m0)
6790
            mstore(0x20, m1)
6791
            mstore(0x40, m2)
6792
            mstore(0x60, m3)
6793
            mstore(0x80, m4)
6794
        }
6795
    }
6796

                            
                        
6797
    function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
6798
        bytes32 m0;
6799
        bytes32 m1;
6800
        bytes32 m2;
6801
        bytes32 m3;
6802
        bytes32 m4;
6803
        /// @solidity memory-safe-assembly
6804
        assembly {
6805
            m0 := mload(0x00)
6806
            m1 := mload(0x20)
6807
            m2 := mload(0x40)
6808
            m3 := mload(0x60)
6809
            m4 := mload(0x80)
6810
            // Selector of `log(bool,uint256,address,bool)`.
6811
            mstore(0x00, 0xb4c314ff)
6812
            mstore(0x20, p0)
6813
            mstore(0x40, p1)
6814
            mstore(0x60, p2)
6815
            mstore(0x80, p3)
6816
        }
6817
        _sendLogPayload(0x1c, 0x84);
6818
        /// @solidity memory-safe-assembly
6819
        assembly {
6820
            mstore(0x00, m0)
6821
            mstore(0x20, m1)
6822
            mstore(0x40, m2)
6823
            mstore(0x60, m3)
6824
            mstore(0x80, m4)
6825
        }
6826
    }
6827

                            
                        
6828
    function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
6829
        bytes32 m0;
6830
        bytes32 m1;
6831
        bytes32 m2;
6832
        bytes32 m3;
6833
        bytes32 m4;
6834
        /// @solidity memory-safe-assembly
6835
        assembly {
6836
            m0 := mload(0x00)
6837
            m1 := mload(0x20)
6838
            m2 := mload(0x40)
6839
            m3 := mload(0x60)
6840
            m4 := mload(0x80)
6841
            // Selector of `log(bool,uint256,address,uint256)`.
6842
            mstore(0x00, 0x1537dc87)
6843
            mstore(0x20, p0)
6844
            mstore(0x40, p1)
6845
            mstore(0x60, p2)
6846
            mstore(0x80, p3)
6847
        }
6848
        _sendLogPayload(0x1c, 0x84);
6849
        /// @solidity memory-safe-assembly
6850
        assembly {
6851
            mstore(0x00, m0)
6852
            mstore(0x20, m1)
6853
            mstore(0x40, m2)
6854
            mstore(0x60, m3)
6855
            mstore(0x80, m4)
6856
        }
6857
    }
6858

                            
                        
6859
    function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {
6860
        bytes32 m0;
6861
        bytes32 m1;
6862
        bytes32 m2;
6863
        bytes32 m3;
6864
        bytes32 m4;
6865
        bytes32 m5;
6866
        bytes32 m6;
6867
        /// @solidity memory-safe-assembly
6868
        assembly {
6869
            function writeString(pos, w) {
6870
                let length := 0
6871
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
6872
                mstore(pos, length)
6873
                let shift := sub(256, shl(3, length))
6874
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
6875
            }
6876
            m0 := mload(0x00)
6877
            m1 := mload(0x20)
6878
            m2 := mload(0x40)
6879
            m3 := mload(0x60)
6880
            m4 := mload(0x80)
6881
            m5 := mload(0xa0)
6882
            m6 := mload(0xc0)
6883
            // Selector of `log(bool,uint256,address,string)`.
6884
            mstore(0x00, 0x1bb3b09a)
6885
            mstore(0x20, p0)
6886
            mstore(0x40, p1)
6887
            mstore(0x60, p2)
6888
            mstore(0x80, 0x80)
6889
            writeString(0xa0, p3)
6890
        }
6891
        _sendLogPayload(0x1c, 0xc4);
6892
        /// @solidity memory-safe-assembly
6893
        assembly {
6894
            mstore(0x00, m0)
6895
            mstore(0x20, m1)
6896
            mstore(0x40, m2)
6897
            mstore(0x60, m3)
6898
            mstore(0x80, m4)
6899
            mstore(0xa0, m5)
6900
            mstore(0xc0, m6)
6901
        }
6902
    }
6903

                            
                        
6904
    function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
6905
        bytes32 m0;
6906
        bytes32 m1;
6907
        bytes32 m2;
6908
        bytes32 m3;
6909
        bytes32 m4;
6910
        /// @solidity memory-safe-assembly
6911
        assembly {
6912
            m0 := mload(0x00)
6913
            m1 := mload(0x20)
6914
            m2 := mload(0x40)
6915
            m3 := mload(0x60)
6916
            m4 := mload(0x80)
6917
            // Selector of `log(bool,uint256,bool,address)`.
6918
            mstore(0x00, 0x9acd3616)
6919
            mstore(0x20, p0)
6920
            mstore(0x40, p1)
6921
            mstore(0x60, p2)
6922
            mstore(0x80, p3)
6923
        }
6924
        _sendLogPayload(0x1c, 0x84);
6925
        /// @solidity memory-safe-assembly
6926
        assembly {
6927
            mstore(0x00, m0)
6928
            mstore(0x20, m1)
6929
            mstore(0x40, m2)
6930
            mstore(0x60, m3)
6931
            mstore(0x80, m4)
6932
        }
6933
    }
6934

                            
                        
6935
    function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
6936
        bytes32 m0;
6937
        bytes32 m1;
6938
        bytes32 m2;
6939
        bytes32 m3;
6940
        bytes32 m4;
6941
        /// @solidity memory-safe-assembly
6942
        assembly {
6943
            m0 := mload(0x00)
6944
            m1 := mload(0x20)
6945
            m2 := mload(0x40)
6946
            m3 := mload(0x60)
6947
            m4 := mload(0x80)
6948
            // Selector of `log(bool,uint256,bool,bool)`.
6949
            mstore(0x00, 0xceb5f4d7)
6950
            mstore(0x20, p0)
6951
            mstore(0x40, p1)
6952
            mstore(0x60, p2)
6953
            mstore(0x80, p3)
6954
        }
6955
        _sendLogPayload(0x1c, 0x84);
6956
        /// @solidity memory-safe-assembly
6957
        assembly {
6958
            mstore(0x00, m0)
6959
            mstore(0x20, m1)
6960
            mstore(0x40, m2)
6961
            mstore(0x60, m3)
6962
            mstore(0x80, m4)
6963
        }
6964
    }
6965

                            
                        
6966
    function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
6967
        bytes32 m0;
6968
        bytes32 m1;
6969
        bytes32 m2;
6970
        bytes32 m3;
6971
        bytes32 m4;
6972
        /// @solidity memory-safe-assembly
6973
        assembly {
6974
            m0 := mload(0x00)
6975
            m1 := mload(0x20)
6976
            m2 := mload(0x40)
6977
            m3 := mload(0x60)
6978
            m4 := mload(0x80)
6979
            // Selector of `log(bool,uint256,bool,uint256)`.
6980
            mstore(0x00, 0x7f9bbca2)
6981
            mstore(0x20, p0)
6982
            mstore(0x40, p1)
6983
            mstore(0x60, p2)
6984
            mstore(0x80, p3)
6985
        }
6986
        _sendLogPayload(0x1c, 0x84);
6987
        /// @solidity memory-safe-assembly
6988
        assembly {
6989
            mstore(0x00, m0)
6990
            mstore(0x20, m1)
6991
            mstore(0x40, m2)
6992
            mstore(0x60, m3)
6993
            mstore(0x80, m4)
6994
        }
6995
    }
6996

                            
                        
6997
    function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {
6998
        bytes32 m0;
6999
        bytes32 m1;
7000
        bytes32 m2;
7001
        bytes32 m3;
7002
        bytes32 m4;
7003
        bytes32 m5;
7004
        bytes32 m6;
7005
        /// @solidity memory-safe-assembly
7006
        assembly {
7007
            function writeString(pos, w) {
7008
                let length := 0
7009
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7010
                mstore(pos, length)
7011
                let shift := sub(256, shl(3, length))
7012
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7013
            }
7014
            m0 := mload(0x00)
7015
            m1 := mload(0x20)
7016
            m2 := mload(0x40)
7017
            m3 := mload(0x60)
7018
            m4 := mload(0x80)
7019
            m5 := mload(0xa0)
7020
            m6 := mload(0xc0)
7021
            // Selector of `log(bool,uint256,bool,string)`.
7022
            mstore(0x00, 0x9143dbb1)
7023
            mstore(0x20, p0)
7024
            mstore(0x40, p1)
7025
            mstore(0x60, p2)
7026
            mstore(0x80, 0x80)
7027
            writeString(0xa0, p3)
7028
        }
7029
        _sendLogPayload(0x1c, 0xc4);
7030
        /// @solidity memory-safe-assembly
7031
        assembly {
7032
            mstore(0x00, m0)
7033
            mstore(0x20, m1)
7034
            mstore(0x40, m2)
7035
            mstore(0x60, m3)
7036
            mstore(0x80, m4)
7037
            mstore(0xa0, m5)
7038
            mstore(0xc0, m6)
7039
        }
7040
    }
7041

                            
                        
7042
    function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
7043
        bytes32 m0;
7044
        bytes32 m1;
7045
        bytes32 m2;
7046
        bytes32 m3;
7047
        bytes32 m4;
7048
        /// @solidity memory-safe-assembly
7049
        assembly {
7050
            m0 := mload(0x00)
7051
            m1 := mload(0x20)
7052
            m2 := mload(0x40)
7053
            m3 := mload(0x60)
7054
            m4 := mload(0x80)
7055
            // Selector of `log(bool,uint256,uint256,address)`.
7056
            mstore(0x00, 0x00dd87b9)
7057
            mstore(0x20, p0)
7058
            mstore(0x40, p1)
7059
            mstore(0x60, p2)
7060
            mstore(0x80, p3)
7061
        }
7062
        _sendLogPayload(0x1c, 0x84);
7063
        /// @solidity memory-safe-assembly
7064
        assembly {
7065
            mstore(0x00, m0)
7066
            mstore(0x20, m1)
7067
            mstore(0x40, m2)
7068
            mstore(0x60, m3)
7069
            mstore(0x80, m4)
7070
        }
7071
    }
7072

                            
                        
7073
    function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
7074
        bytes32 m0;
7075
        bytes32 m1;
7076
        bytes32 m2;
7077
        bytes32 m3;
7078
        bytes32 m4;
7079
        /// @solidity memory-safe-assembly
7080
        assembly {
7081
            m0 := mload(0x00)
7082
            m1 := mload(0x20)
7083
            m2 := mload(0x40)
7084
            m3 := mload(0x60)
7085
            m4 := mload(0x80)
7086
            // Selector of `log(bool,uint256,uint256,bool)`.
7087
            mstore(0x00, 0xbe984353)
7088
            mstore(0x20, p0)
7089
            mstore(0x40, p1)
7090
            mstore(0x60, p2)
7091
            mstore(0x80, p3)
7092
        }
7093
        _sendLogPayload(0x1c, 0x84);
7094
        /// @solidity memory-safe-assembly
7095
        assembly {
7096
            mstore(0x00, m0)
7097
            mstore(0x20, m1)
7098
            mstore(0x40, m2)
7099
            mstore(0x60, m3)
7100
            mstore(0x80, m4)
7101
        }
7102
    }
7103

                            
                        
7104
    function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
7105
        bytes32 m0;
7106
        bytes32 m1;
7107
        bytes32 m2;
7108
        bytes32 m3;
7109
        bytes32 m4;
7110
        /// @solidity memory-safe-assembly
7111
        assembly {
7112
            m0 := mload(0x00)
7113
            m1 := mload(0x20)
7114
            m2 := mload(0x40)
7115
            m3 := mload(0x60)
7116
            m4 := mload(0x80)
7117
            // Selector of `log(bool,uint256,uint256,uint256)`.
7118
            mstore(0x00, 0x374bb4b2)
7119
            mstore(0x20, p0)
7120
            mstore(0x40, p1)
7121
            mstore(0x60, p2)
7122
            mstore(0x80, p3)
7123
        }
7124
        _sendLogPayload(0x1c, 0x84);
7125
        /// @solidity memory-safe-assembly
7126
        assembly {
7127
            mstore(0x00, m0)
7128
            mstore(0x20, m1)
7129
            mstore(0x40, m2)
7130
            mstore(0x60, m3)
7131
            mstore(0x80, m4)
7132
        }
7133
    }
7134

                            
                        
7135
    function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
7136
        bytes32 m0;
7137
        bytes32 m1;
7138
        bytes32 m2;
7139
        bytes32 m3;
7140
        bytes32 m4;
7141
        bytes32 m5;
7142
        bytes32 m6;
7143
        /// @solidity memory-safe-assembly
7144
        assembly {
7145
            function writeString(pos, w) {
7146
                let length := 0
7147
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7148
                mstore(pos, length)
7149
                let shift := sub(256, shl(3, length))
7150
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7151
            }
7152
            m0 := mload(0x00)
7153
            m1 := mload(0x20)
7154
            m2 := mload(0x40)
7155
            m3 := mload(0x60)
7156
            m4 := mload(0x80)
7157
            m5 := mload(0xa0)
7158
            m6 := mload(0xc0)
7159
            // Selector of `log(bool,uint256,uint256,string)`.
7160
            mstore(0x00, 0x8e69fb5d)
7161
            mstore(0x20, p0)
7162
            mstore(0x40, p1)
7163
            mstore(0x60, p2)
7164
            mstore(0x80, 0x80)
7165
            writeString(0xa0, p3)
7166
        }
7167
        _sendLogPayload(0x1c, 0xc4);
7168
        /// @solidity memory-safe-assembly
7169
        assembly {
7170
            mstore(0x00, m0)
7171
            mstore(0x20, m1)
7172
            mstore(0x40, m2)
7173
            mstore(0x60, m3)
7174
            mstore(0x80, m4)
7175
            mstore(0xa0, m5)
7176
            mstore(0xc0, m6)
7177
        }
7178
    }
7179

                            
                        
7180
    function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {
7181
        bytes32 m0;
7182
        bytes32 m1;
7183
        bytes32 m2;
7184
        bytes32 m3;
7185
        bytes32 m4;
7186
        bytes32 m5;
7187
        bytes32 m6;
7188
        /// @solidity memory-safe-assembly
7189
        assembly {
7190
            function writeString(pos, w) {
7191
                let length := 0
7192
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7193
                mstore(pos, length)
7194
                let shift := sub(256, shl(3, length))
7195
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7196
            }
7197
            m0 := mload(0x00)
7198
            m1 := mload(0x20)
7199
            m2 := mload(0x40)
7200
            m3 := mload(0x60)
7201
            m4 := mload(0x80)
7202
            m5 := mload(0xa0)
7203
            m6 := mload(0xc0)
7204
            // Selector of `log(bool,uint256,string,address)`.
7205
            mstore(0x00, 0xfedd1fff)
7206
            mstore(0x20, p0)
7207
            mstore(0x40, p1)
7208
            mstore(0x60, 0x80)
7209
            mstore(0x80, p3)
7210
            writeString(0xa0, p2)
7211
        }
7212
        _sendLogPayload(0x1c, 0xc4);
7213
        /// @solidity memory-safe-assembly
7214
        assembly {
7215
            mstore(0x00, m0)
7216
            mstore(0x20, m1)
7217
            mstore(0x40, m2)
7218
            mstore(0x60, m3)
7219
            mstore(0x80, m4)
7220
            mstore(0xa0, m5)
7221
            mstore(0xc0, m6)
7222
        }
7223
    }
7224

                            
                        
7225
    function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {
7226
        bytes32 m0;
7227
        bytes32 m1;
7228
        bytes32 m2;
7229
        bytes32 m3;
7230
        bytes32 m4;
7231
        bytes32 m5;
7232
        bytes32 m6;
7233
        /// @solidity memory-safe-assembly
7234
        assembly {
7235
            function writeString(pos, w) {
7236
                let length := 0
7237
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7238
                mstore(pos, length)
7239
                let shift := sub(256, shl(3, length))
7240
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7241
            }
7242
            m0 := mload(0x00)
7243
            m1 := mload(0x20)
7244
            m2 := mload(0x40)
7245
            m3 := mload(0x60)
7246
            m4 := mload(0x80)
7247
            m5 := mload(0xa0)
7248
            m6 := mload(0xc0)
7249
            // Selector of `log(bool,uint256,string,bool)`.
7250
            mstore(0x00, 0xe5e70b2b)
7251
            mstore(0x20, p0)
7252
            mstore(0x40, p1)
7253
            mstore(0x60, 0x80)
7254
            mstore(0x80, p3)
7255
            writeString(0xa0, p2)
7256
        }
7257
        _sendLogPayload(0x1c, 0xc4);
7258
        /// @solidity memory-safe-assembly
7259
        assembly {
7260
            mstore(0x00, m0)
7261
            mstore(0x20, m1)
7262
            mstore(0x40, m2)
7263
            mstore(0x60, m3)
7264
            mstore(0x80, m4)
7265
            mstore(0xa0, m5)
7266
            mstore(0xc0, m6)
7267
        }
7268
    }
7269

                            
                        
7270
    function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
7271
        bytes32 m0;
7272
        bytes32 m1;
7273
        bytes32 m2;
7274
        bytes32 m3;
7275
        bytes32 m4;
7276
        bytes32 m5;
7277
        bytes32 m6;
7278
        /// @solidity memory-safe-assembly
7279
        assembly {
7280
            function writeString(pos, w) {
7281
                let length := 0
7282
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7283
                mstore(pos, length)
7284
                let shift := sub(256, shl(3, length))
7285
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7286
            }
7287
            m0 := mload(0x00)
7288
            m1 := mload(0x20)
7289
            m2 := mload(0x40)
7290
            m3 := mload(0x60)
7291
            m4 := mload(0x80)
7292
            m5 := mload(0xa0)
7293
            m6 := mload(0xc0)
7294
            // Selector of `log(bool,uint256,string,uint256)`.
7295
            mstore(0x00, 0x6a1199e2)
7296
            mstore(0x20, p0)
7297
            mstore(0x40, p1)
7298
            mstore(0x60, 0x80)
7299
            mstore(0x80, p3)
7300
            writeString(0xa0, p2)
7301
        }
7302
        _sendLogPayload(0x1c, 0xc4);
7303
        /// @solidity memory-safe-assembly
7304
        assembly {
7305
            mstore(0x00, m0)
7306
            mstore(0x20, m1)
7307
            mstore(0x40, m2)
7308
            mstore(0x60, m3)
7309
            mstore(0x80, m4)
7310
            mstore(0xa0, m5)
7311
            mstore(0xc0, m6)
7312
        }
7313
    }
7314

                            
                        
7315
    function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
7316
        bytes32 m0;
7317
        bytes32 m1;
7318
        bytes32 m2;
7319
        bytes32 m3;
7320
        bytes32 m4;
7321
        bytes32 m5;
7322
        bytes32 m6;
7323
        bytes32 m7;
7324
        bytes32 m8;
7325
        /// @solidity memory-safe-assembly
7326
        assembly {
7327
            function writeString(pos, w) {
7328
                let length := 0
7329
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7330
                mstore(pos, length)
7331
                let shift := sub(256, shl(3, length))
7332
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7333
            }
7334
            m0 := mload(0x00)
7335
            m1 := mload(0x20)
7336
            m2 := mload(0x40)
7337
            m3 := mload(0x60)
7338
            m4 := mload(0x80)
7339
            m5 := mload(0xa0)
7340
            m6 := mload(0xc0)
7341
            m7 := mload(0xe0)
7342
            m8 := mload(0x100)
7343
            // Selector of `log(bool,uint256,string,string)`.
7344
            mstore(0x00, 0xf5bc2249)
7345
            mstore(0x20, p0)
7346
            mstore(0x40, p1)
7347
            mstore(0x60, 0x80)
7348
            mstore(0x80, 0xc0)
7349
            writeString(0xa0, p2)
7350
            writeString(0xe0, p3)
7351
        }
7352
        _sendLogPayload(0x1c, 0x104);
7353
        /// @solidity memory-safe-assembly
7354
        assembly {
7355
            mstore(0x00, m0)
7356
            mstore(0x20, m1)
7357
            mstore(0x40, m2)
7358
            mstore(0x60, m3)
7359
            mstore(0x80, m4)
7360
            mstore(0xa0, m5)
7361
            mstore(0xc0, m6)
7362
            mstore(0xe0, m7)
7363
            mstore(0x100, m8)
7364
        }
7365
    }
7366

                            
                        
7367
    function log(bool p0, bytes32 p1, address p2, address p3) internal pure {
7368
        bytes32 m0;
7369
        bytes32 m1;
7370
        bytes32 m2;
7371
        bytes32 m3;
7372
        bytes32 m4;
7373
        bytes32 m5;
7374
        bytes32 m6;
7375
        /// @solidity memory-safe-assembly
7376
        assembly {
7377
            function writeString(pos, w) {
7378
                let length := 0
7379
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7380
                mstore(pos, length)
7381
                let shift := sub(256, shl(3, length))
7382
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7383
            }
7384
            m0 := mload(0x00)
7385
            m1 := mload(0x20)
7386
            m2 := mload(0x40)
7387
            m3 := mload(0x60)
7388
            m4 := mload(0x80)
7389
            m5 := mload(0xa0)
7390
            m6 := mload(0xc0)
7391
            // Selector of `log(bool,string,address,address)`.
7392
            mstore(0x00, 0x2b2b18dc)
7393
            mstore(0x20, p0)
7394
            mstore(0x40, 0x80)
7395
            mstore(0x60, p2)
7396
            mstore(0x80, p3)
7397
            writeString(0xa0, p1)
7398
        }
7399
        _sendLogPayload(0x1c, 0xc4);
7400
        /// @solidity memory-safe-assembly
7401
        assembly {
7402
            mstore(0x00, m0)
7403
            mstore(0x20, m1)
7404
            mstore(0x40, m2)
7405
            mstore(0x60, m3)
7406
            mstore(0x80, m4)
7407
            mstore(0xa0, m5)
7408
            mstore(0xc0, m6)
7409
        }
7410
    }
7411

                            
                        
7412
    function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {
7413
        bytes32 m0;
7414
        bytes32 m1;
7415
        bytes32 m2;
7416
        bytes32 m3;
7417
        bytes32 m4;
7418
        bytes32 m5;
7419
        bytes32 m6;
7420
        /// @solidity memory-safe-assembly
7421
        assembly {
7422
            function writeString(pos, w) {
7423
                let length := 0
7424
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7425
                mstore(pos, length)
7426
                let shift := sub(256, shl(3, length))
7427
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7428
            }
7429
            m0 := mload(0x00)
7430
            m1 := mload(0x20)
7431
            m2 := mload(0x40)
7432
            m3 := mload(0x60)
7433
            m4 := mload(0x80)
7434
            m5 := mload(0xa0)
7435
            m6 := mload(0xc0)
7436
            // Selector of `log(bool,string,address,bool)`.
7437
            mstore(0x00, 0x6dd434ca)
7438
            mstore(0x20, p0)
7439
            mstore(0x40, 0x80)
7440
            mstore(0x60, p2)
7441
            mstore(0x80, p3)
7442
            writeString(0xa0, p1)
7443
        }
7444
        _sendLogPayload(0x1c, 0xc4);
7445
        /// @solidity memory-safe-assembly
7446
        assembly {
7447
            mstore(0x00, m0)
7448
            mstore(0x20, m1)
7449
            mstore(0x40, m2)
7450
            mstore(0x60, m3)
7451
            mstore(0x80, m4)
7452
            mstore(0xa0, m5)
7453
            mstore(0xc0, m6)
7454
        }
7455
    }
7456

                            
                        
7457
    function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {
7458
        bytes32 m0;
7459
        bytes32 m1;
7460
        bytes32 m2;
7461
        bytes32 m3;
7462
        bytes32 m4;
7463
        bytes32 m5;
7464
        bytes32 m6;
7465
        /// @solidity memory-safe-assembly
7466
        assembly {
7467
            function writeString(pos, w) {
7468
                let length := 0
7469
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7470
                mstore(pos, length)
7471
                let shift := sub(256, shl(3, length))
7472
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7473
            }
7474
            m0 := mload(0x00)
7475
            m1 := mload(0x20)
7476
            m2 := mload(0x40)
7477
            m3 := mload(0x60)
7478
            m4 := mload(0x80)
7479
            m5 := mload(0xa0)
7480
            m6 := mload(0xc0)
7481
            // Selector of `log(bool,string,address,uint256)`.
7482
            mstore(0x00, 0xa5cada94)
7483
            mstore(0x20, p0)
7484
            mstore(0x40, 0x80)
7485
            mstore(0x60, p2)
7486
            mstore(0x80, p3)
7487
            writeString(0xa0, p1)
7488
        }
7489
        _sendLogPayload(0x1c, 0xc4);
7490
        /// @solidity memory-safe-assembly
7491
        assembly {
7492
            mstore(0x00, m0)
7493
            mstore(0x20, m1)
7494
            mstore(0x40, m2)
7495
            mstore(0x60, m3)
7496
            mstore(0x80, m4)
7497
            mstore(0xa0, m5)
7498
            mstore(0xc0, m6)
7499
        }
7500
    }
7501

                            
                        
7502
    function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {
7503
        bytes32 m0;
7504
        bytes32 m1;
7505
        bytes32 m2;
7506
        bytes32 m3;
7507
        bytes32 m4;
7508
        bytes32 m5;
7509
        bytes32 m6;
7510
        bytes32 m7;
7511
        bytes32 m8;
7512
        /// @solidity memory-safe-assembly
7513
        assembly {
7514
            function writeString(pos, w) {
7515
                let length := 0
7516
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7517
                mstore(pos, length)
7518
                let shift := sub(256, shl(3, length))
7519
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7520
            }
7521
            m0 := mload(0x00)
7522
            m1 := mload(0x20)
7523
            m2 := mload(0x40)
7524
            m3 := mload(0x60)
7525
            m4 := mload(0x80)
7526
            m5 := mload(0xa0)
7527
            m6 := mload(0xc0)
7528
            m7 := mload(0xe0)
7529
            m8 := mload(0x100)
7530
            // Selector of `log(bool,string,address,string)`.
7531
            mstore(0x00, 0x12d6c788)
7532
            mstore(0x20, p0)
7533
            mstore(0x40, 0x80)
7534
            mstore(0x60, p2)
7535
            mstore(0x80, 0xc0)
7536
            writeString(0xa0, p1)
7537
            writeString(0xe0, p3)
7538
        }
7539
        _sendLogPayload(0x1c, 0x104);
7540
        /// @solidity memory-safe-assembly
7541
        assembly {
7542
            mstore(0x00, m0)
7543
            mstore(0x20, m1)
7544
            mstore(0x40, m2)
7545
            mstore(0x60, m3)
7546
            mstore(0x80, m4)
7547
            mstore(0xa0, m5)
7548
            mstore(0xc0, m6)
7549
            mstore(0xe0, m7)
7550
            mstore(0x100, m8)
7551
        }
7552
    }
7553

                            
                        
7554
    function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {
7555
        bytes32 m0;
7556
        bytes32 m1;
7557
        bytes32 m2;
7558
        bytes32 m3;
7559
        bytes32 m4;
7560
        bytes32 m5;
7561
        bytes32 m6;
7562
        /// @solidity memory-safe-assembly
7563
        assembly {
7564
            function writeString(pos, w) {
7565
                let length := 0
7566
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7567
                mstore(pos, length)
7568
                let shift := sub(256, shl(3, length))
7569
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7570
            }
7571
            m0 := mload(0x00)
7572
            m1 := mload(0x20)
7573
            m2 := mload(0x40)
7574
            m3 := mload(0x60)
7575
            m4 := mload(0x80)
7576
            m5 := mload(0xa0)
7577
            m6 := mload(0xc0)
7578
            // Selector of `log(bool,string,bool,address)`.
7579
            mstore(0x00, 0x538e06ab)
7580
            mstore(0x20, p0)
7581
            mstore(0x40, 0x80)
7582
            mstore(0x60, p2)
7583
            mstore(0x80, p3)
7584
            writeString(0xa0, p1)
7585
        }
7586
        _sendLogPayload(0x1c, 0xc4);
7587
        /// @solidity memory-safe-assembly
7588
        assembly {
7589
            mstore(0x00, m0)
7590
            mstore(0x20, m1)
7591
            mstore(0x40, m2)
7592
            mstore(0x60, m3)
7593
            mstore(0x80, m4)
7594
            mstore(0xa0, m5)
7595
            mstore(0xc0, m6)
7596
        }
7597
    }
7598

                            
                        
7599
    function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {
7600
        bytes32 m0;
7601
        bytes32 m1;
7602
        bytes32 m2;
7603
        bytes32 m3;
7604
        bytes32 m4;
7605
        bytes32 m5;
7606
        bytes32 m6;
7607
        /// @solidity memory-safe-assembly
7608
        assembly {
7609
            function writeString(pos, w) {
7610
                let length := 0
7611
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7612
                mstore(pos, length)
7613
                let shift := sub(256, shl(3, length))
7614
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7615
            }
7616
            m0 := mload(0x00)
7617
            m1 := mload(0x20)
7618
            m2 := mload(0x40)
7619
            m3 := mload(0x60)
7620
            m4 := mload(0x80)
7621
            m5 := mload(0xa0)
7622
            m6 := mload(0xc0)
7623
            // Selector of `log(bool,string,bool,bool)`.
7624
            mstore(0x00, 0xdc5e935b)
7625
            mstore(0x20, p0)
7626
            mstore(0x40, 0x80)
7627
            mstore(0x60, p2)
7628
            mstore(0x80, p3)
7629
            writeString(0xa0, p1)
7630
        }
7631
        _sendLogPayload(0x1c, 0xc4);
7632
        /// @solidity memory-safe-assembly
7633
        assembly {
7634
            mstore(0x00, m0)
7635
            mstore(0x20, m1)
7636
            mstore(0x40, m2)
7637
            mstore(0x60, m3)
7638
            mstore(0x80, m4)
7639
            mstore(0xa0, m5)
7640
            mstore(0xc0, m6)
7641
        }
7642
    }
7643

                            
                        
7644
    function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {
7645
        bytes32 m0;
7646
        bytes32 m1;
7647
        bytes32 m2;
7648
        bytes32 m3;
7649
        bytes32 m4;
7650
        bytes32 m5;
7651
        bytes32 m6;
7652
        /// @solidity memory-safe-assembly
7653
        assembly {
7654
            function writeString(pos, w) {
7655
                let length := 0
7656
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7657
                mstore(pos, length)
7658
                let shift := sub(256, shl(3, length))
7659
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7660
            }
7661
            m0 := mload(0x00)
7662
            m1 := mload(0x20)
7663
            m2 := mload(0x40)
7664
            m3 := mload(0x60)
7665
            m4 := mload(0x80)
7666
            m5 := mload(0xa0)
7667
            m6 := mload(0xc0)
7668
            // Selector of `log(bool,string,bool,uint256)`.
7669
            mstore(0x00, 0x1606a393)
7670
            mstore(0x20, p0)
7671
            mstore(0x40, 0x80)
7672
            mstore(0x60, p2)
7673
            mstore(0x80, p3)
7674
            writeString(0xa0, p1)
7675
        }
7676
        _sendLogPayload(0x1c, 0xc4);
7677
        /// @solidity memory-safe-assembly
7678
        assembly {
7679
            mstore(0x00, m0)
7680
            mstore(0x20, m1)
7681
            mstore(0x40, m2)
7682
            mstore(0x60, m3)
7683
            mstore(0x80, m4)
7684
            mstore(0xa0, m5)
7685
            mstore(0xc0, m6)
7686
        }
7687
    }
7688

                            
                        
7689
    function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
7690
        bytes32 m0;
7691
        bytes32 m1;
7692
        bytes32 m2;
7693
        bytes32 m3;
7694
        bytes32 m4;
7695
        bytes32 m5;
7696
        bytes32 m6;
7697
        bytes32 m7;
7698
        bytes32 m8;
7699
        /// @solidity memory-safe-assembly
7700
        assembly {
7701
            function writeString(pos, w) {
7702
                let length := 0
7703
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7704
                mstore(pos, length)
7705
                let shift := sub(256, shl(3, length))
7706
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7707
            }
7708
            m0 := mload(0x00)
7709
            m1 := mload(0x20)
7710
            m2 := mload(0x40)
7711
            m3 := mload(0x60)
7712
            m4 := mload(0x80)
7713
            m5 := mload(0xa0)
7714
            m6 := mload(0xc0)
7715
            m7 := mload(0xe0)
7716
            m8 := mload(0x100)
7717
            // Selector of `log(bool,string,bool,string)`.
7718
            mstore(0x00, 0x483d0416)
7719
            mstore(0x20, p0)
7720
            mstore(0x40, 0x80)
7721
            mstore(0x60, p2)
7722
            mstore(0x80, 0xc0)
7723
            writeString(0xa0, p1)
7724
            writeString(0xe0, p3)
7725
        }
7726
        _sendLogPayload(0x1c, 0x104);
7727
        /// @solidity memory-safe-assembly
7728
        assembly {
7729
            mstore(0x00, m0)
7730
            mstore(0x20, m1)
7731
            mstore(0x40, m2)
7732
            mstore(0x60, m3)
7733
            mstore(0x80, m4)
7734
            mstore(0xa0, m5)
7735
            mstore(0xc0, m6)
7736
            mstore(0xe0, m7)
7737
            mstore(0x100, m8)
7738
        }
7739
    }
7740

                            
                        
7741
    function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {
7742
        bytes32 m0;
7743
        bytes32 m1;
7744
        bytes32 m2;
7745
        bytes32 m3;
7746
        bytes32 m4;
7747
        bytes32 m5;
7748
        bytes32 m6;
7749
        /// @solidity memory-safe-assembly
7750
        assembly {
7751
            function writeString(pos, w) {
7752
                let length := 0
7753
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7754
                mstore(pos, length)
7755
                let shift := sub(256, shl(3, length))
7756
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7757
            }
7758
            m0 := mload(0x00)
7759
            m1 := mload(0x20)
7760
            m2 := mload(0x40)
7761
            m3 := mload(0x60)
7762
            m4 := mload(0x80)
7763
            m5 := mload(0xa0)
7764
            m6 := mload(0xc0)
7765
            // Selector of `log(bool,string,uint256,address)`.
7766
            mstore(0x00, 0x1596a1ce)
7767
            mstore(0x20, p0)
7768
            mstore(0x40, 0x80)
7769
            mstore(0x60, p2)
7770
            mstore(0x80, p3)
7771
            writeString(0xa0, p1)
7772
        }
7773
        _sendLogPayload(0x1c, 0xc4);
7774
        /// @solidity memory-safe-assembly
7775
        assembly {
7776
            mstore(0x00, m0)
7777
            mstore(0x20, m1)
7778
            mstore(0x40, m2)
7779
            mstore(0x60, m3)
7780
            mstore(0x80, m4)
7781
            mstore(0xa0, m5)
7782
            mstore(0xc0, m6)
7783
        }
7784
    }
7785

                            
                        
7786
    function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {
7787
        bytes32 m0;
7788
        bytes32 m1;
7789
        bytes32 m2;
7790
        bytes32 m3;
7791
        bytes32 m4;
7792
        bytes32 m5;
7793
        bytes32 m6;
7794
        /// @solidity memory-safe-assembly
7795
        assembly {
7796
            function writeString(pos, w) {
7797
                let length := 0
7798
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7799
                mstore(pos, length)
7800
                let shift := sub(256, shl(3, length))
7801
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7802
            }
7803
            m0 := mload(0x00)
7804
            m1 := mload(0x20)
7805
            m2 := mload(0x40)
7806
            m3 := mload(0x60)
7807
            m4 := mload(0x80)
7808
            m5 := mload(0xa0)
7809
            m6 := mload(0xc0)
7810
            // Selector of `log(bool,string,uint256,bool)`.
7811
            mstore(0x00, 0x6b0e5d53)
7812
            mstore(0x20, p0)
7813
            mstore(0x40, 0x80)
7814
            mstore(0x60, p2)
7815
            mstore(0x80, p3)
7816
            writeString(0xa0, p1)
7817
        }
7818
        _sendLogPayload(0x1c, 0xc4);
7819
        /// @solidity memory-safe-assembly
7820
        assembly {
7821
            mstore(0x00, m0)
7822
            mstore(0x20, m1)
7823
            mstore(0x40, m2)
7824
            mstore(0x60, m3)
7825
            mstore(0x80, m4)
7826
            mstore(0xa0, m5)
7827
            mstore(0xc0, m6)
7828
        }
7829
    }
7830

                            
                        
7831
    function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
7832
        bytes32 m0;
7833
        bytes32 m1;
7834
        bytes32 m2;
7835
        bytes32 m3;
7836
        bytes32 m4;
7837
        bytes32 m5;
7838
        bytes32 m6;
7839
        /// @solidity memory-safe-assembly
7840
        assembly {
7841
            function writeString(pos, w) {
7842
                let length := 0
7843
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7844
                mstore(pos, length)
7845
                let shift := sub(256, shl(3, length))
7846
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7847
            }
7848
            m0 := mload(0x00)
7849
            m1 := mload(0x20)
7850
            m2 := mload(0x40)
7851
            m3 := mload(0x60)
7852
            m4 := mload(0x80)
7853
            m5 := mload(0xa0)
7854
            m6 := mload(0xc0)
7855
            // Selector of `log(bool,string,uint256,uint256)`.
7856
            mstore(0x00, 0x28863fcb)
7857
            mstore(0x20, p0)
7858
            mstore(0x40, 0x80)
7859
            mstore(0x60, p2)
7860
            mstore(0x80, p3)
7861
            writeString(0xa0, p1)
7862
        }
7863
        _sendLogPayload(0x1c, 0xc4);
7864
        /// @solidity memory-safe-assembly
7865
        assembly {
7866
            mstore(0x00, m0)
7867
            mstore(0x20, m1)
7868
            mstore(0x40, m2)
7869
            mstore(0x60, m3)
7870
            mstore(0x80, m4)
7871
            mstore(0xa0, m5)
7872
            mstore(0xc0, m6)
7873
        }
7874
    }
7875

                            
                        
7876
    function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
7877
        bytes32 m0;
7878
        bytes32 m1;
7879
        bytes32 m2;
7880
        bytes32 m3;
7881
        bytes32 m4;
7882
        bytes32 m5;
7883
        bytes32 m6;
7884
        bytes32 m7;
7885
        bytes32 m8;
7886
        /// @solidity memory-safe-assembly
7887
        assembly {
7888
            function writeString(pos, w) {
7889
                let length := 0
7890
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7891
                mstore(pos, length)
7892
                let shift := sub(256, shl(3, length))
7893
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7894
            }
7895
            m0 := mload(0x00)
7896
            m1 := mload(0x20)
7897
            m2 := mload(0x40)
7898
            m3 := mload(0x60)
7899
            m4 := mload(0x80)
7900
            m5 := mload(0xa0)
7901
            m6 := mload(0xc0)
7902
            m7 := mload(0xe0)
7903
            m8 := mload(0x100)
7904
            // Selector of `log(bool,string,uint256,string)`.
7905
            mstore(0x00, 0x1ad96de6)
7906
            mstore(0x20, p0)
7907
            mstore(0x40, 0x80)
7908
            mstore(0x60, p2)
7909
            mstore(0x80, 0xc0)
7910
            writeString(0xa0, p1)
7911
            writeString(0xe0, p3)
7912
        }
7913
        _sendLogPayload(0x1c, 0x104);
7914
        /// @solidity memory-safe-assembly
7915
        assembly {
7916
            mstore(0x00, m0)
7917
            mstore(0x20, m1)
7918
            mstore(0x40, m2)
7919
            mstore(0x60, m3)
7920
            mstore(0x80, m4)
7921
            mstore(0xa0, m5)
7922
            mstore(0xc0, m6)
7923
            mstore(0xe0, m7)
7924
            mstore(0x100, m8)
7925
        }
7926
    }
7927

                            
                        
7928
    function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {
7929
        bytes32 m0;
7930
        bytes32 m1;
7931
        bytes32 m2;
7932
        bytes32 m3;
7933
        bytes32 m4;
7934
        bytes32 m5;
7935
        bytes32 m6;
7936
        bytes32 m7;
7937
        bytes32 m8;
7938
        /// @solidity memory-safe-assembly
7939
        assembly {
7940
            function writeString(pos, w) {
7941
                let length := 0
7942
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7943
                mstore(pos, length)
7944
                let shift := sub(256, shl(3, length))
7945
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7946
            }
7947
            m0 := mload(0x00)
7948
            m1 := mload(0x20)
7949
            m2 := mload(0x40)
7950
            m3 := mload(0x60)
7951
            m4 := mload(0x80)
7952
            m5 := mload(0xa0)
7953
            m6 := mload(0xc0)
7954
            m7 := mload(0xe0)
7955
            m8 := mload(0x100)
7956
            // Selector of `log(bool,string,string,address)`.
7957
            mstore(0x00, 0x97d394d8)
7958
            mstore(0x20, p0)
7959
            mstore(0x40, 0x80)
7960
            mstore(0x60, 0xc0)
7961
            mstore(0x80, p3)
7962
            writeString(0xa0, p1)
7963
            writeString(0xe0, p2)
7964
        }
7965
        _sendLogPayload(0x1c, 0x104);
7966
        /// @solidity memory-safe-assembly
7967
        assembly {
7968
            mstore(0x00, m0)
7969
            mstore(0x20, m1)
7970
            mstore(0x40, m2)
7971
            mstore(0x60, m3)
7972
            mstore(0x80, m4)
7973
            mstore(0xa0, m5)
7974
            mstore(0xc0, m6)
7975
            mstore(0xe0, m7)
7976
            mstore(0x100, m8)
7977
        }
7978
    }
7979

                            
                        
7980
    function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
7981
        bytes32 m0;
7982
        bytes32 m1;
7983
        bytes32 m2;
7984
        bytes32 m3;
7985
        bytes32 m4;
7986
        bytes32 m5;
7987
        bytes32 m6;
7988
        bytes32 m7;
7989
        bytes32 m8;
7990
        /// @solidity memory-safe-assembly
7991
        assembly {
7992
            function writeString(pos, w) {
7993
                let length := 0
7994
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
7995
                mstore(pos, length)
7996
                let shift := sub(256, shl(3, length))
7997
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
7998
            }
7999
            m0 := mload(0x00)
8000
            m1 := mload(0x20)
8001
            m2 := mload(0x40)
8002
            m3 := mload(0x60)
8003
            m4 := mload(0x80)
8004
            m5 := mload(0xa0)
8005
            m6 := mload(0xc0)
8006
            m7 := mload(0xe0)
8007
            m8 := mload(0x100)
8008
            // Selector of `log(bool,string,string,bool)`.
8009
            mstore(0x00, 0x1e4b87e5)
8010
            mstore(0x20, p0)
8011
            mstore(0x40, 0x80)
8012
            mstore(0x60, 0xc0)
8013
            mstore(0x80, p3)
8014
            writeString(0xa0, p1)
8015
            writeString(0xe0, p2)
8016
        }
8017
        _sendLogPayload(0x1c, 0x104);
8018
        /// @solidity memory-safe-assembly
8019
        assembly {
8020
            mstore(0x00, m0)
8021
            mstore(0x20, m1)
8022
            mstore(0x40, m2)
8023
            mstore(0x60, m3)
8024
            mstore(0x80, m4)
8025
            mstore(0xa0, m5)
8026
            mstore(0xc0, m6)
8027
            mstore(0xe0, m7)
8028
            mstore(0x100, m8)
8029
        }
8030
    }
8031

                            
                        
8032
    function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
8033
        bytes32 m0;
8034
        bytes32 m1;
8035
        bytes32 m2;
8036
        bytes32 m3;
8037
        bytes32 m4;
8038
        bytes32 m5;
8039
        bytes32 m6;
8040
        bytes32 m7;
8041
        bytes32 m8;
8042
        /// @solidity memory-safe-assembly
8043
        assembly {
8044
            function writeString(pos, w) {
8045
                let length := 0
8046
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8047
                mstore(pos, length)
8048
                let shift := sub(256, shl(3, length))
8049
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8050
            }
8051
            m0 := mload(0x00)
8052
            m1 := mload(0x20)
8053
            m2 := mload(0x40)
8054
            m3 := mload(0x60)
8055
            m4 := mload(0x80)
8056
            m5 := mload(0xa0)
8057
            m6 := mload(0xc0)
8058
            m7 := mload(0xe0)
8059
            m8 := mload(0x100)
8060
            // Selector of `log(bool,string,string,uint256)`.
8061
            mstore(0x00, 0x7be0c3eb)
8062
            mstore(0x20, p0)
8063
            mstore(0x40, 0x80)
8064
            mstore(0x60, 0xc0)
8065
            mstore(0x80, p3)
8066
            writeString(0xa0, p1)
8067
            writeString(0xe0, p2)
8068
        }
8069
        _sendLogPayload(0x1c, 0x104);
8070
        /// @solidity memory-safe-assembly
8071
        assembly {
8072
            mstore(0x00, m0)
8073
            mstore(0x20, m1)
8074
            mstore(0x40, m2)
8075
            mstore(0x60, m3)
8076
            mstore(0x80, m4)
8077
            mstore(0xa0, m5)
8078
            mstore(0xc0, m6)
8079
            mstore(0xe0, m7)
8080
            mstore(0x100, m8)
8081
        }
8082
    }
8083

                            
                        
8084
    function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
8085
        bytes32 m0;
8086
        bytes32 m1;
8087
        bytes32 m2;
8088
        bytes32 m3;
8089
        bytes32 m4;
8090
        bytes32 m5;
8091
        bytes32 m6;
8092
        bytes32 m7;
8093
        bytes32 m8;
8094
        bytes32 m9;
8095
        bytes32 m10;
8096
        /// @solidity memory-safe-assembly
8097
        assembly {
8098
            function writeString(pos, w) {
8099
                let length := 0
8100
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8101
                mstore(pos, length)
8102
                let shift := sub(256, shl(3, length))
8103
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8104
            }
8105
            m0 := mload(0x00)
8106
            m1 := mload(0x20)
8107
            m2 := mload(0x40)
8108
            m3 := mload(0x60)
8109
            m4 := mload(0x80)
8110
            m5 := mload(0xa0)
8111
            m6 := mload(0xc0)
8112
            m7 := mload(0xe0)
8113
            m8 := mload(0x100)
8114
            m9 := mload(0x120)
8115
            m10 := mload(0x140)
8116
            // Selector of `log(bool,string,string,string)`.
8117
            mstore(0x00, 0x1762e32a)
8118
            mstore(0x20, p0)
8119
            mstore(0x40, 0x80)
8120
            mstore(0x60, 0xc0)
8121
            mstore(0x80, 0x100)
8122
            writeString(0xa0, p1)
8123
            writeString(0xe0, p2)
8124
            writeString(0x120, p3)
8125
        }
8126
        _sendLogPayload(0x1c, 0x144);
8127
        /// @solidity memory-safe-assembly
8128
        assembly {
8129
            mstore(0x00, m0)
8130
            mstore(0x20, m1)
8131
            mstore(0x40, m2)
8132
            mstore(0x60, m3)
8133
            mstore(0x80, m4)
8134
            mstore(0xa0, m5)
8135
            mstore(0xc0, m6)
8136
            mstore(0xe0, m7)
8137
            mstore(0x100, m8)
8138
            mstore(0x120, m9)
8139
            mstore(0x140, m10)
8140
        }
8141
    }
8142

                            
                        
8143
    function log(uint256 p0, address p1, address p2, address p3) internal pure {
8144
        bytes32 m0;
8145
        bytes32 m1;
8146
        bytes32 m2;
8147
        bytes32 m3;
8148
        bytes32 m4;
8149
        /// @solidity memory-safe-assembly
8150
        assembly {
8151
            m0 := mload(0x00)
8152
            m1 := mload(0x20)
8153
            m2 := mload(0x40)
8154
            m3 := mload(0x60)
8155
            m4 := mload(0x80)
8156
            // Selector of `log(uint256,address,address,address)`.
8157
            mstore(0x00, 0x2488b414)
8158
            mstore(0x20, p0)
8159
            mstore(0x40, p1)
8160
            mstore(0x60, p2)
8161
            mstore(0x80, p3)
8162
        }
8163
        _sendLogPayload(0x1c, 0x84);
8164
        /// @solidity memory-safe-assembly
8165
        assembly {
8166
            mstore(0x00, m0)
8167
            mstore(0x20, m1)
8168
            mstore(0x40, m2)
8169
            mstore(0x60, m3)
8170
            mstore(0x80, m4)
8171
        }
8172
    }
8173

                            
                        
8174
    function log(uint256 p0, address p1, address p2, bool p3) internal pure {
8175
        bytes32 m0;
8176
        bytes32 m1;
8177
        bytes32 m2;
8178
        bytes32 m3;
8179
        bytes32 m4;
8180
        /// @solidity memory-safe-assembly
8181
        assembly {
8182
            m0 := mload(0x00)
8183
            m1 := mload(0x20)
8184
            m2 := mload(0x40)
8185
            m3 := mload(0x60)
8186
            m4 := mload(0x80)
8187
            // Selector of `log(uint256,address,address,bool)`.
8188
            mstore(0x00, 0x091ffaf5)
8189
            mstore(0x20, p0)
8190
            mstore(0x40, p1)
8191
            mstore(0x60, p2)
8192
            mstore(0x80, p3)
8193
        }
8194
        _sendLogPayload(0x1c, 0x84);
8195
        /// @solidity memory-safe-assembly
8196
        assembly {
8197
            mstore(0x00, m0)
8198
            mstore(0x20, m1)
8199
            mstore(0x40, m2)
8200
            mstore(0x60, m3)
8201
            mstore(0x80, m4)
8202
        }
8203
    }
8204

                            
                        
8205
    function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
8206
        bytes32 m0;
8207
        bytes32 m1;
8208
        bytes32 m2;
8209
        bytes32 m3;
8210
        bytes32 m4;
8211
        /// @solidity memory-safe-assembly
8212
        assembly {
8213
            m0 := mload(0x00)
8214
            m1 := mload(0x20)
8215
            m2 := mload(0x40)
8216
            m3 := mload(0x60)
8217
            m4 := mload(0x80)
8218
            // Selector of `log(uint256,address,address,uint256)`.
8219
            mstore(0x00, 0x736efbb6)
8220
            mstore(0x20, p0)
8221
            mstore(0x40, p1)
8222
            mstore(0x60, p2)
8223
            mstore(0x80, p3)
8224
        }
8225
        _sendLogPayload(0x1c, 0x84);
8226
        /// @solidity memory-safe-assembly
8227
        assembly {
8228
            mstore(0x00, m0)
8229
            mstore(0x20, m1)
8230
            mstore(0x40, m2)
8231
            mstore(0x60, m3)
8232
            mstore(0x80, m4)
8233
        }
8234
    }
8235

                            
                        
8236
    function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {
8237
        bytes32 m0;
8238
        bytes32 m1;
8239
        bytes32 m2;
8240
        bytes32 m3;
8241
        bytes32 m4;
8242
        bytes32 m5;
8243
        bytes32 m6;
8244
        /// @solidity memory-safe-assembly
8245
        assembly {
8246
            function writeString(pos, w) {
8247
                let length := 0
8248
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8249
                mstore(pos, length)
8250
                let shift := sub(256, shl(3, length))
8251
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8252
            }
8253
            m0 := mload(0x00)
8254
            m1 := mload(0x20)
8255
            m2 := mload(0x40)
8256
            m3 := mload(0x60)
8257
            m4 := mload(0x80)
8258
            m5 := mload(0xa0)
8259
            m6 := mload(0xc0)
8260
            // Selector of `log(uint256,address,address,string)`.
8261
            mstore(0x00, 0x031c6f73)
8262
            mstore(0x20, p0)
8263
            mstore(0x40, p1)
8264
            mstore(0x60, p2)
8265
            mstore(0x80, 0x80)
8266
            writeString(0xa0, p3)
8267
        }
8268
        _sendLogPayload(0x1c, 0xc4);
8269
        /// @solidity memory-safe-assembly
8270
        assembly {
8271
            mstore(0x00, m0)
8272
            mstore(0x20, m1)
8273
            mstore(0x40, m2)
8274
            mstore(0x60, m3)
8275
            mstore(0x80, m4)
8276
            mstore(0xa0, m5)
8277
            mstore(0xc0, m6)
8278
        }
8279
    }
8280

                            
                        
8281
    function log(uint256 p0, address p1, bool p2, address p3) internal pure {
8282
        bytes32 m0;
8283
        bytes32 m1;
8284
        bytes32 m2;
8285
        bytes32 m3;
8286
        bytes32 m4;
8287
        /// @solidity memory-safe-assembly
8288
        assembly {
8289
            m0 := mload(0x00)
8290
            m1 := mload(0x20)
8291
            m2 := mload(0x40)
8292
            m3 := mload(0x60)
8293
            m4 := mload(0x80)
8294
            // Selector of `log(uint256,address,bool,address)`.
8295
            mstore(0x00, 0xef72c513)
8296
            mstore(0x20, p0)
8297
            mstore(0x40, p1)
8298
            mstore(0x60, p2)
8299
            mstore(0x80, p3)
8300
        }
8301
        _sendLogPayload(0x1c, 0x84);
8302
        /// @solidity memory-safe-assembly
8303
        assembly {
8304
            mstore(0x00, m0)
8305
            mstore(0x20, m1)
8306
            mstore(0x40, m2)
8307
            mstore(0x60, m3)
8308
            mstore(0x80, m4)
8309
        }
8310
    }
8311

                            
                        
8312
    function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
8313
        bytes32 m0;
8314
        bytes32 m1;
8315
        bytes32 m2;
8316
        bytes32 m3;
8317
        bytes32 m4;
8318
        /// @solidity memory-safe-assembly
8319
        assembly {
8320
            m0 := mload(0x00)
8321
            m1 := mload(0x20)
8322
            m2 := mload(0x40)
8323
            m3 := mload(0x60)
8324
            m4 := mload(0x80)
8325
            // Selector of `log(uint256,address,bool,bool)`.
8326
            mstore(0x00, 0xe351140f)
8327
            mstore(0x20, p0)
8328
            mstore(0x40, p1)
8329
            mstore(0x60, p2)
8330
            mstore(0x80, p3)
8331
        }
8332
        _sendLogPayload(0x1c, 0x84);
8333
        /// @solidity memory-safe-assembly
8334
        assembly {
8335
            mstore(0x00, m0)
8336
            mstore(0x20, m1)
8337
            mstore(0x40, m2)
8338
            mstore(0x60, m3)
8339
            mstore(0x80, m4)
8340
        }
8341
    }
8342

                            
                        
8343
    function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
8344
        bytes32 m0;
8345
        bytes32 m1;
8346
        bytes32 m2;
8347
        bytes32 m3;
8348
        bytes32 m4;
8349
        /// @solidity memory-safe-assembly
8350
        assembly {
8351
            m0 := mload(0x00)
8352
            m1 := mload(0x20)
8353
            m2 := mload(0x40)
8354
            m3 := mload(0x60)
8355
            m4 := mload(0x80)
8356
            // Selector of `log(uint256,address,bool,uint256)`.
8357
            mstore(0x00, 0x5abd992a)
8358
            mstore(0x20, p0)
8359
            mstore(0x40, p1)
8360
            mstore(0x60, p2)
8361
            mstore(0x80, p3)
8362
        }
8363
        _sendLogPayload(0x1c, 0x84);
8364
        /// @solidity memory-safe-assembly
8365
        assembly {
8366
            mstore(0x00, m0)
8367
            mstore(0x20, m1)
8368
            mstore(0x40, m2)
8369
            mstore(0x60, m3)
8370
            mstore(0x80, m4)
8371
        }
8372
    }
8373

                            
                        
8374
    function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {
8375
        bytes32 m0;
8376
        bytes32 m1;
8377
        bytes32 m2;
8378
        bytes32 m3;
8379
        bytes32 m4;
8380
        bytes32 m5;
8381
        bytes32 m6;
8382
        /// @solidity memory-safe-assembly
8383
        assembly {
8384
            function writeString(pos, w) {
8385
                let length := 0
8386
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8387
                mstore(pos, length)
8388
                let shift := sub(256, shl(3, length))
8389
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8390
            }
8391
            m0 := mload(0x00)
8392
            m1 := mload(0x20)
8393
            m2 := mload(0x40)
8394
            m3 := mload(0x60)
8395
            m4 := mload(0x80)
8396
            m5 := mload(0xa0)
8397
            m6 := mload(0xc0)
8398
            // Selector of `log(uint256,address,bool,string)`.
8399
            mstore(0x00, 0x90fb06aa)
8400
            mstore(0x20, p0)
8401
            mstore(0x40, p1)
8402
            mstore(0x60, p2)
8403
            mstore(0x80, 0x80)
8404
            writeString(0xa0, p3)
8405
        }
8406
        _sendLogPayload(0x1c, 0xc4);
8407
        /// @solidity memory-safe-assembly
8408
        assembly {
8409
            mstore(0x00, m0)
8410
            mstore(0x20, m1)
8411
            mstore(0x40, m2)
8412
            mstore(0x60, m3)
8413
            mstore(0x80, m4)
8414
            mstore(0xa0, m5)
8415
            mstore(0xc0, m6)
8416
        }
8417
    }
8418

                            
                        
8419
    function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
8420
        bytes32 m0;
8421
        bytes32 m1;
8422
        bytes32 m2;
8423
        bytes32 m3;
8424
        bytes32 m4;
8425
        /// @solidity memory-safe-assembly
8426
        assembly {
8427
            m0 := mload(0x00)
8428
            m1 := mload(0x20)
8429
            m2 := mload(0x40)
8430
            m3 := mload(0x60)
8431
            m4 := mload(0x80)
8432
            // Selector of `log(uint256,address,uint256,address)`.
8433
            mstore(0x00, 0x15c127b5)
8434
            mstore(0x20, p0)
8435
            mstore(0x40, p1)
8436
            mstore(0x60, p2)
8437
            mstore(0x80, p3)
8438
        }
8439
        _sendLogPayload(0x1c, 0x84);
8440
        /// @solidity memory-safe-assembly
8441
        assembly {
8442
            mstore(0x00, m0)
8443
            mstore(0x20, m1)
8444
            mstore(0x40, m2)
8445
            mstore(0x60, m3)
8446
            mstore(0x80, m4)
8447
        }
8448
    }
8449

                            
                        
8450
    function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
8451
        bytes32 m0;
8452
        bytes32 m1;
8453
        bytes32 m2;
8454
        bytes32 m3;
8455
        bytes32 m4;
8456
        /// @solidity memory-safe-assembly
8457
        assembly {
8458
            m0 := mload(0x00)
8459
            m1 := mload(0x20)
8460
            m2 := mload(0x40)
8461
            m3 := mload(0x60)
8462
            m4 := mload(0x80)
8463
            // Selector of `log(uint256,address,uint256,bool)`.
8464
            mstore(0x00, 0x5f743a7c)
8465
            mstore(0x20, p0)
8466
            mstore(0x40, p1)
8467
            mstore(0x60, p2)
8468
            mstore(0x80, p3)
8469
        }
8470
        _sendLogPayload(0x1c, 0x84);
8471
        /// @solidity memory-safe-assembly
8472
        assembly {
8473
            mstore(0x00, m0)
8474
            mstore(0x20, m1)
8475
            mstore(0x40, m2)
8476
            mstore(0x60, m3)
8477
            mstore(0x80, m4)
8478
        }
8479
    }
8480

                            
                        
8481
    function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
8482
        bytes32 m0;
8483
        bytes32 m1;
8484
        bytes32 m2;
8485
        bytes32 m3;
8486
        bytes32 m4;
8487
        /// @solidity memory-safe-assembly
8488
        assembly {
8489
            m0 := mload(0x00)
8490
            m1 := mload(0x20)
8491
            m2 := mload(0x40)
8492
            m3 := mload(0x60)
8493
            m4 := mload(0x80)
8494
            // Selector of `log(uint256,address,uint256,uint256)`.
8495
            mstore(0x00, 0x0c9cd9c1)
8496
            mstore(0x20, p0)
8497
            mstore(0x40, p1)
8498
            mstore(0x60, p2)
8499
            mstore(0x80, p3)
8500
        }
8501
        _sendLogPayload(0x1c, 0x84);
8502
        /// @solidity memory-safe-assembly
8503
        assembly {
8504
            mstore(0x00, m0)
8505
            mstore(0x20, m1)
8506
            mstore(0x40, m2)
8507
            mstore(0x60, m3)
8508
            mstore(0x80, m4)
8509
        }
8510
    }
8511

                            
                        
8512
    function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {
8513
        bytes32 m0;
8514
        bytes32 m1;
8515
        bytes32 m2;
8516
        bytes32 m3;
8517
        bytes32 m4;
8518
        bytes32 m5;
8519
        bytes32 m6;
8520
        /// @solidity memory-safe-assembly
8521
        assembly {
8522
            function writeString(pos, w) {
8523
                let length := 0
8524
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8525
                mstore(pos, length)
8526
                let shift := sub(256, shl(3, length))
8527
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8528
            }
8529
            m0 := mload(0x00)
8530
            m1 := mload(0x20)
8531
            m2 := mload(0x40)
8532
            m3 := mload(0x60)
8533
            m4 := mload(0x80)
8534
            m5 := mload(0xa0)
8535
            m6 := mload(0xc0)
8536
            // Selector of `log(uint256,address,uint256,string)`.
8537
            mstore(0x00, 0xddb06521)
8538
            mstore(0x20, p0)
8539
            mstore(0x40, p1)
8540
            mstore(0x60, p2)
8541
            mstore(0x80, 0x80)
8542
            writeString(0xa0, p3)
8543
        }
8544
        _sendLogPayload(0x1c, 0xc4);
8545
        /// @solidity memory-safe-assembly
8546
        assembly {
8547
            mstore(0x00, m0)
8548
            mstore(0x20, m1)
8549
            mstore(0x40, m2)
8550
            mstore(0x60, m3)
8551
            mstore(0x80, m4)
8552
            mstore(0xa0, m5)
8553
            mstore(0xc0, m6)
8554
        }
8555
    }
8556

                            
                        
8557
    function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {
8558
        bytes32 m0;
8559
        bytes32 m1;
8560
        bytes32 m2;
8561
        bytes32 m3;
8562
        bytes32 m4;
8563
        bytes32 m5;
8564
        bytes32 m6;
8565
        /// @solidity memory-safe-assembly
8566
        assembly {
8567
            function writeString(pos, w) {
8568
                let length := 0
8569
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8570
                mstore(pos, length)
8571
                let shift := sub(256, shl(3, length))
8572
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8573
            }
8574
            m0 := mload(0x00)
8575
            m1 := mload(0x20)
8576
            m2 := mload(0x40)
8577
            m3 := mload(0x60)
8578
            m4 := mload(0x80)
8579
            m5 := mload(0xa0)
8580
            m6 := mload(0xc0)
8581
            // Selector of `log(uint256,address,string,address)`.
8582
            mstore(0x00, 0x9cba8fff)
8583
            mstore(0x20, p0)
8584
            mstore(0x40, p1)
8585
            mstore(0x60, 0x80)
8586
            mstore(0x80, p3)
8587
            writeString(0xa0, p2)
8588
        }
8589
        _sendLogPayload(0x1c, 0xc4);
8590
        /// @solidity memory-safe-assembly
8591
        assembly {
8592
            mstore(0x00, m0)
8593
            mstore(0x20, m1)
8594
            mstore(0x40, m2)
8595
            mstore(0x60, m3)
8596
            mstore(0x80, m4)
8597
            mstore(0xa0, m5)
8598
            mstore(0xc0, m6)
8599
        }
8600
    }
8601

                            
                        
8602
    function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {
8603
        bytes32 m0;
8604
        bytes32 m1;
8605
        bytes32 m2;
8606
        bytes32 m3;
8607
        bytes32 m4;
8608
        bytes32 m5;
8609
        bytes32 m6;
8610
        /// @solidity memory-safe-assembly
8611
        assembly {
8612
            function writeString(pos, w) {
8613
                let length := 0
8614
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8615
                mstore(pos, length)
8616
                let shift := sub(256, shl(3, length))
8617
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8618
            }
8619
            m0 := mload(0x00)
8620
            m1 := mload(0x20)
8621
            m2 := mload(0x40)
8622
            m3 := mload(0x60)
8623
            m4 := mload(0x80)
8624
            m5 := mload(0xa0)
8625
            m6 := mload(0xc0)
8626
            // Selector of `log(uint256,address,string,bool)`.
8627
            mstore(0x00, 0xcc32ab07)
8628
            mstore(0x20, p0)
8629
            mstore(0x40, p1)
8630
            mstore(0x60, 0x80)
8631
            mstore(0x80, p3)
8632
            writeString(0xa0, p2)
8633
        }
8634
        _sendLogPayload(0x1c, 0xc4);
8635
        /// @solidity memory-safe-assembly
8636
        assembly {
8637
            mstore(0x00, m0)
8638
            mstore(0x20, m1)
8639
            mstore(0x40, m2)
8640
            mstore(0x60, m3)
8641
            mstore(0x80, m4)
8642
            mstore(0xa0, m5)
8643
            mstore(0xc0, m6)
8644
        }
8645
    }
8646

                            
                        
8647
    function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {
8648
        bytes32 m0;
8649
        bytes32 m1;
8650
        bytes32 m2;
8651
        bytes32 m3;
8652
        bytes32 m4;
8653
        bytes32 m5;
8654
        bytes32 m6;
8655
        /// @solidity memory-safe-assembly
8656
        assembly {
8657
            function writeString(pos, w) {
8658
                let length := 0
8659
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8660
                mstore(pos, length)
8661
                let shift := sub(256, shl(3, length))
8662
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8663
            }
8664
            m0 := mload(0x00)
8665
            m1 := mload(0x20)
8666
            m2 := mload(0x40)
8667
            m3 := mload(0x60)
8668
            m4 := mload(0x80)
8669
            m5 := mload(0xa0)
8670
            m6 := mload(0xc0)
8671
            // Selector of `log(uint256,address,string,uint256)`.
8672
            mstore(0x00, 0x46826b5d)
8673
            mstore(0x20, p0)
8674
            mstore(0x40, p1)
8675
            mstore(0x60, 0x80)
8676
            mstore(0x80, p3)
8677
            writeString(0xa0, p2)
8678
        }
8679
        _sendLogPayload(0x1c, 0xc4);
8680
        /// @solidity memory-safe-assembly
8681
        assembly {
8682
            mstore(0x00, m0)
8683
            mstore(0x20, m1)
8684
            mstore(0x40, m2)
8685
            mstore(0x60, m3)
8686
            mstore(0x80, m4)
8687
            mstore(0xa0, m5)
8688
            mstore(0xc0, m6)
8689
        }
8690
    }
8691

                            
                        
8692
    function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
8693
        bytes32 m0;
8694
        bytes32 m1;
8695
        bytes32 m2;
8696
        bytes32 m3;
8697
        bytes32 m4;
8698
        bytes32 m5;
8699
        bytes32 m6;
8700
        bytes32 m7;
8701
        bytes32 m8;
8702
        /// @solidity memory-safe-assembly
8703
        assembly {
8704
            function writeString(pos, w) {
8705
                let length := 0
8706
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8707
                mstore(pos, length)
8708
                let shift := sub(256, shl(3, length))
8709
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8710
            }
8711
            m0 := mload(0x00)
8712
            m1 := mload(0x20)
8713
            m2 := mload(0x40)
8714
            m3 := mload(0x60)
8715
            m4 := mload(0x80)
8716
            m5 := mload(0xa0)
8717
            m6 := mload(0xc0)
8718
            m7 := mload(0xe0)
8719
            m8 := mload(0x100)
8720
            // Selector of `log(uint256,address,string,string)`.
8721
            mstore(0x00, 0x3e128ca3)
8722
            mstore(0x20, p0)
8723
            mstore(0x40, p1)
8724
            mstore(0x60, 0x80)
8725
            mstore(0x80, 0xc0)
8726
            writeString(0xa0, p2)
8727
            writeString(0xe0, p3)
8728
        }
8729
        _sendLogPayload(0x1c, 0x104);
8730
        /// @solidity memory-safe-assembly
8731
        assembly {
8732
            mstore(0x00, m0)
8733
            mstore(0x20, m1)
8734
            mstore(0x40, m2)
8735
            mstore(0x60, m3)
8736
            mstore(0x80, m4)
8737
            mstore(0xa0, m5)
8738
            mstore(0xc0, m6)
8739
            mstore(0xe0, m7)
8740
            mstore(0x100, m8)
8741
        }
8742
    }
8743

                            
                        
8744
    function log(uint256 p0, bool p1, address p2, address p3) internal pure {
8745
        bytes32 m0;
8746
        bytes32 m1;
8747
        bytes32 m2;
8748
        bytes32 m3;
8749
        bytes32 m4;
8750
        /// @solidity memory-safe-assembly
8751
        assembly {
8752
            m0 := mload(0x00)
8753
            m1 := mload(0x20)
8754
            m2 := mload(0x40)
8755
            m3 := mload(0x60)
8756
            m4 := mload(0x80)
8757
            // Selector of `log(uint256,bool,address,address)`.
8758
            mstore(0x00, 0xa1ef4cbb)
8759
            mstore(0x20, p0)
8760
            mstore(0x40, p1)
8761
            mstore(0x60, p2)
8762
            mstore(0x80, p3)
8763
        }
8764
        _sendLogPayload(0x1c, 0x84);
8765
        /// @solidity memory-safe-assembly
8766
        assembly {
8767
            mstore(0x00, m0)
8768
            mstore(0x20, m1)
8769
            mstore(0x40, m2)
8770
            mstore(0x60, m3)
8771
            mstore(0x80, m4)
8772
        }
8773
    }
8774

                            
                        
8775
    function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
8776
        bytes32 m0;
8777
        bytes32 m1;
8778
        bytes32 m2;
8779
        bytes32 m3;
8780
        bytes32 m4;
8781
        /// @solidity memory-safe-assembly
8782
        assembly {
8783
            m0 := mload(0x00)
8784
            m1 := mload(0x20)
8785
            m2 := mload(0x40)
8786
            m3 := mload(0x60)
8787
            m4 := mload(0x80)
8788
            // Selector of `log(uint256,bool,address,bool)`.
8789
            mstore(0x00, 0x454d54a5)
8790
            mstore(0x20, p0)
8791
            mstore(0x40, p1)
8792
            mstore(0x60, p2)
8793
            mstore(0x80, p3)
8794
        }
8795
        _sendLogPayload(0x1c, 0x84);
8796
        /// @solidity memory-safe-assembly
8797
        assembly {
8798
            mstore(0x00, m0)
8799
            mstore(0x20, m1)
8800
            mstore(0x40, m2)
8801
            mstore(0x60, m3)
8802
            mstore(0x80, m4)
8803
        }
8804
    }
8805

                            
                        
8806
    function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
8807
        bytes32 m0;
8808
        bytes32 m1;
8809
        bytes32 m2;
8810
        bytes32 m3;
8811
        bytes32 m4;
8812
        /// @solidity memory-safe-assembly
8813
        assembly {
8814
            m0 := mload(0x00)
8815
            m1 := mload(0x20)
8816
            m2 := mload(0x40)
8817
            m3 := mload(0x60)
8818
            m4 := mload(0x80)
8819
            // Selector of `log(uint256,bool,address,uint256)`.
8820
            mstore(0x00, 0x078287f5)
8821
            mstore(0x20, p0)
8822
            mstore(0x40, p1)
8823
            mstore(0x60, p2)
8824
            mstore(0x80, p3)
8825
        }
8826
        _sendLogPayload(0x1c, 0x84);
8827
        /// @solidity memory-safe-assembly
8828
        assembly {
8829
            mstore(0x00, m0)
8830
            mstore(0x20, m1)
8831
            mstore(0x40, m2)
8832
            mstore(0x60, m3)
8833
            mstore(0x80, m4)
8834
        }
8835
    }
8836

                            
                        
8837
    function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {
8838
        bytes32 m0;
8839
        bytes32 m1;
8840
        bytes32 m2;
8841
        bytes32 m3;
8842
        bytes32 m4;
8843
        bytes32 m5;
8844
        bytes32 m6;
8845
        /// @solidity memory-safe-assembly
8846
        assembly {
8847
            function writeString(pos, w) {
8848
                let length := 0
8849
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8850
                mstore(pos, length)
8851
                let shift := sub(256, shl(3, length))
8852
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8853
            }
8854
            m0 := mload(0x00)
8855
            m1 := mload(0x20)
8856
            m2 := mload(0x40)
8857
            m3 := mload(0x60)
8858
            m4 := mload(0x80)
8859
            m5 := mload(0xa0)
8860
            m6 := mload(0xc0)
8861
            // Selector of `log(uint256,bool,address,string)`.
8862
            mstore(0x00, 0xade052c7)
8863
            mstore(0x20, p0)
8864
            mstore(0x40, p1)
8865
            mstore(0x60, p2)
8866
            mstore(0x80, 0x80)
8867
            writeString(0xa0, p3)
8868
        }
8869
        _sendLogPayload(0x1c, 0xc4);
8870
        /// @solidity memory-safe-assembly
8871
        assembly {
8872
            mstore(0x00, m0)
8873
            mstore(0x20, m1)
8874
            mstore(0x40, m2)
8875
            mstore(0x60, m3)
8876
            mstore(0x80, m4)
8877
            mstore(0xa0, m5)
8878
            mstore(0xc0, m6)
8879
        }
8880
    }
8881

                            
                        
8882
    function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
8883
        bytes32 m0;
8884
        bytes32 m1;
8885
        bytes32 m2;
8886
        bytes32 m3;
8887
        bytes32 m4;
8888
        /// @solidity memory-safe-assembly
8889
        assembly {
8890
            m0 := mload(0x00)
8891
            m1 := mload(0x20)
8892
            m2 := mload(0x40)
8893
            m3 := mload(0x60)
8894
            m4 := mload(0x80)
8895
            // Selector of `log(uint256,bool,bool,address)`.
8896
            mstore(0x00, 0x69640b59)
8897
            mstore(0x20, p0)
8898
            mstore(0x40, p1)
8899
            mstore(0x60, p2)
8900
            mstore(0x80, p3)
8901
        }
8902
        _sendLogPayload(0x1c, 0x84);
8903
        /// @solidity memory-safe-assembly
8904
        assembly {
8905
            mstore(0x00, m0)
8906
            mstore(0x20, m1)
8907
            mstore(0x40, m2)
8908
            mstore(0x60, m3)
8909
            mstore(0x80, m4)
8910
        }
8911
    }
8912

                            
                        
8913
    function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
8914
        bytes32 m0;
8915
        bytes32 m1;
8916
        bytes32 m2;
8917
        bytes32 m3;
8918
        bytes32 m4;
8919
        /// @solidity memory-safe-assembly
8920
        assembly {
8921
            m0 := mload(0x00)
8922
            m1 := mload(0x20)
8923
            m2 := mload(0x40)
8924
            m3 := mload(0x60)
8925
            m4 := mload(0x80)
8926
            // Selector of `log(uint256,bool,bool,bool)`.
8927
            mstore(0x00, 0xb6f577a1)
8928
            mstore(0x20, p0)
8929
            mstore(0x40, p1)
8930
            mstore(0x60, p2)
8931
            mstore(0x80, p3)
8932
        }
8933
        _sendLogPayload(0x1c, 0x84);
8934
        /// @solidity memory-safe-assembly
8935
        assembly {
8936
            mstore(0x00, m0)
8937
            mstore(0x20, m1)
8938
            mstore(0x40, m2)
8939
            mstore(0x60, m3)
8940
            mstore(0x80, m4)
8941
        }
8942
    }
8943

                            
                        
8944
    function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
8945
        bytes32 m0;
8946
        bytes32 m1;
8947
        bytes32 m2;
8948
        bytes32 m3;
8949
        bytes32 m4;
8950
        /// @solidity memory-safe-assembly
8951
        assembly {
8952
            m0 := mload(0x00)
8953
            m1 := mload(0x20)
8954
            m2 := mload(0x40)
8955
            m3 := mload(0x60)
8956
            m4 := mload(0x80)
8957
            // Selector of `log(uint256,bool,bool,uint256)`.
8958
            mstore(0x00, 0x7464ce23)
8959
            mstore(0x20, p0)
8960
            mstore(0x40, p1)
8961
            mstore(0x60, p2)
8962
            mstore(0x80, p3)
8963
        }
8964
        _sendLogPayload(0x1c, 0x84);
8965
        /// @solidity memory-safe-assembly
8966
        assembly {
8967
            mstore(0x00, m0)
8968
            mstore(0x20, m1)
8969
            mstore(0x40, m2)
8970
            mstore(0x60, m3)
8971
            mstore(0x80, m4)
8972
        }
8973
    }
8974

                            
                        
8975
    function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {
8976
        bytes32 m0;
8977
        bytes32 m1;
8978
        bytes32 m2;
8979
        bytes32 m3;
8980
        bytes32 m4;
8981
        bytes32 m5;
8982
        bytes32 m6;
8983
        /// @solidity memory-safe-assembly
8984
        assembly {
8985
            function writeString(pos, w) {
8986
                let length := 0
8987
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
8988
                mstore(pos, length)
8989
                let shift := sub(256, shl(3, length))
8990
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
8991
            }
8992
            m0 := mload(0x00)
8993
            m1 := mload(0x20)
8994
            m2 := mload(0x40)
8995
            m3 := mload(0x60)
8996
            m4 := mload(0x80)
8997
            m5 := mload(0xa0)
8998
            m6 := mload(0xc0)
8999
            // Selector of `log(uint256,bool,bool,string)`.
9000
            mstore(0x00, 0xdddb9561)
9001
            mstore(0x20, p0)
9002
            mstore(0x40, p1)
9003
            mstore(0x60, p2)
9004
            mstore(0x80, 0x80)
9005
            writeString(0xa0, p3)
9006
        }
9007
        _sendLogPayload(0x1c, 0xc4);
9008
        /// @solidity memory-safe-assembly
9009
        assembly {
9010
            mstore(0x00, m0)
9011
            mstore(0x20, m1)
9012
            mstore(0x40, m2)
9013
            mstore(0x60, m3)
9014
            mstore(0x80, m4)
9015
            mstore(0xa0, m5)
9016
            mstore(0xc0, m6)
9017
        }
9018
    }
9019

                            
                        
9020
    function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
9021
        bytes32 m0;
9022
        bytes32 m1;
9023
        bytes32 m2;
9024
        bytes32 m3;
9025
        bytes32 m4;
9026
        /// @solidity memory-safe-assembly
9027
        assembly {
9028
            m0 := mload(0x00)
9029
            m1 := mload(0x20)
9030
            m2 := mload(0x40)
9031
            m3 := mload(0x60)
9032
            m4 := mload(0x80)
9033
            // Selector of `log(uint256,bool,uint256,address)`.
9034
            mstore(0x00, 0x88cb6041)
9035
            mstore(0x20, p0)
9036
            mstore(0x40, p1)
9037
            mstore(0x60, p2)
9038
            mstore(0x80, p3)
9039
        }
9040
        _sendLogPayload(0x1c, 0x84);
9041
        /// @solidity memory-safe-assembly
9042
        assembly {
9043
            mstore(0x00, m0)
9044
            mstore(0x20, m1)
9045
            mstore(0x40, m2)
9046
            mstore(0x60, m3)
9047
            mstore(0x80, m4)
9048
        }
9049
    }
9050

                            
                        
9051
    function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
9052
        bytes32 m0;
9053
        bytes32 m1;
9054
        bytes32 m2;
9055
        bytes32 m3;
9056
        bytes32 m4;
9057
        /// @solidity memory-safe-assembly
9058
        assembly {
9059
            m0 := mload(0x00)
9060
            m1 := mload(0x20)
9061
            m2 := mload(0x40)
9062
            m3 := mload(0x60)
9063
            m4 := mload(0x80)
9064
            // Selector of `log(uint256,bool,uint256,bool)`.
9065
            mstore(0x00, 0x91a02e2a)
9066
            mstore(0x20, p0)
9067
            mstore(0x40, p1)
9068
            mstore(0x60, p2)
9069
            mstore(0x80, p3)
9070
        }
9071
        _sendLogPayload(0x1c, 0x84);
9072
        /// @solidity memory-safe-assembly
9073
        assembly {
9074
            mstore(0x00, m0)
9075
            mstore(0x20, m1)
9076
            mstore(0x40, m2)
9077
            mstore(0x60, m3)
9078
            mstore(0x80, m4)
9079
        }
9080
    }
9081

                            
                        
9082
    function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
9083
        bytes32 m0;
9084
        bytes32 m1;
9085
        bytes32 m2;
9086
        bytes32 m3;
9087
        bytes32 m4;
9088
        /// @solidity memory-safe-assembly
9089
        assembly {
9090
            m0 := mload(0x00)
9091
            m1 := mload(0x20)
9092
            m2 := mload(0x40)
9093
            m3 := mload(0x60)
9094
            m4 := mload(0x80)
9095
            // Selector of `log(uint256,bool,uint256,uint256)`.
9096
            mstore(0x00, 0xc6acc7a8)
9097
            mstore(0x20, p0)
9098
            mstore(0x40, p1)
9099
            mstore(0x60, p2)
9100
            mstore(0x80, p3)
9101
        }
9102
        _sendLogPayload(0x1c, 0x84);
9103
        /// @solidity memory-safe-assembly
9104
        assembly {
9105
            mstore(0x00, m0)
9106
            mstore(0x20, m1)
9107
            mstore(0x40, m2)
9108
            mstore(0x60, m3)
9109
            mstore(0x80, m4)
9110
        }
9111
    }
9112

                            
                        
9113
    function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
9114
        bytes32 m0;
9115
        bytes32 m1;
9116
        bytes32 m2;
9117
        bytes32 m3;
9118
        bytes32 m4;
9119
        bytes32 m5;
9120
        bytes32 m6;
9121
        /// @solidity memory-safe-assembly
9122
        assembly {
9123
            function writeString(pos, w) {
9124
                let length := 0
9125
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9126
                mstore(pos, length)
9127
                let shift := sub(256, shl(3, length))
9128
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9129
            }
9130
            m0 := mload(0x00)
9131
            m1 := mload(0x20)
9132
            m2 := mload(0x40)
9133
            m3 := mload(0x60)
9134
            m4 := mload(0x80)
9135
            m5 := mload(0xa0)
9136
            m6 := mload(0xc0)
9137
            // Selector of `log(uint256,bool,uint256,string)`.
9138
            mstore(0x00, 0xde03e774)
9139
            mstore(0x20, p0)
9140
            mstore(0x40, p1)
9141
            mstore(0x60, p2)
9142
            mstore(0x80, 0x80)
9143
            writeString(0xa0, p3)
9144
        }
9145
        _sendLogPayload(0x1c, 0xc4);
9146
        /// @solidity memory-safe-assembly
9147
        assembly {
9148
            mstore(0x00, m0)
9149
            mstore(0x20, m1)
9150
            mstore(0x40, m2)
9151
            mstore(0x60, m3)
9152
            mstore(0x80, m4)
9153
            mstore(0xa0, m5)
9154
            mstore(0xc0, m6)
9155
        }
9156
    }
9157

                            
                        
9158
    function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {
9159
        bytes32 m0;
9160
        bytes32 m1;
9161
        bytes32 m2;
9162
        bytes32 m3;
9163
        bytes32 m4;
9164
        bytes32 m5;
9165
        bytes32 m6;
9166
        /// @solidity memory-safe-assembly
9167
        assembly {
9168
            function writeString(pos, w) {
9169
                let length := 0
9170
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9171
                mstore(pos, length)
9172
                let shift := sub(256, shl(3, length))
9173
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9174
            }
9175
            m0 := mload(0x00)
9176
            m1 := mload(0x20)
9177
            m2 := mload(0x40)
9178
            m3 := mload(0x60)
9179
            m4 := mload(0x80)
9180
            m5 := mload(0xa0)
9181
            m6 := mload(0xc0)
9182
            // Selector of `log(uint256,bool,string,address)`.
9183
            mstore(0x00, 0xef529018)
9184
            mstore(0x20, p0)
9185
            mstore(0x40, p1)
9186
            mstore(0x60, 0x80)
9187
            mstore(0x80, p3)
9188
            writeString(0xa0, p2)
9189
        }
9190
        _sendLogPayload(0x1c, 0xc4);
9191
        /// @solidity memory-safe-assembly
9192
        assembly {
9193
            mstore(0x00, m0)
9194
            mstore(0x20, m1)
9195
            mstore(0x40, m2)
9196
            mstore(0x60, m3)
9197
            mstore(0x80, m4)
9198
            mstore(0xa0, m5)
9199
            mstore(0xc0, m6)
9200
        }
9201
    }
9202

                            
                        
9203
    function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {
9204
        bytes32 m0;
9205
        bytes32 m1;
9206
        bytes32 m2;
9207
        bytes32 m3;
9208
        bytes32 m4;
9209
        bytes32 m5;
9210
        bytes32 m6;
9211
        /// @solidity memory-safe-assembly
9212
        assembly {
9213
            function writeString(pos, w) {
9214
                let length := 0
9215
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9216
                mstore(pos, length)
9217
                let shift := sub(256, shl(3, length))
9218
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9219
            }
9220
            m0 := mload(0x00)
9221
            m1 := mload(0x20)
9222
            m2 := mload(0x40)
9223
            m3 := mload(0x60)
9224
            m4 := mload(0x80)
9225
            m5 := mload(0xa0)
9226
            m6 := mload(0xc0)
9227
            // Selector of `log(uint256,bool,string,bool)`.
9228
            mstore(0x00, 0xeb928d7f)
9229
            mstore(0x20, p0)
9230
            mstore(0x40, p1)
9231
            mstore(0x60, 0x80)
9232
            mstore(0x80, p3)
9233
            writeString(0xa0, p2)
9234
        }
9235
        _sendLogPayload(0x1c, 0xc4);
9236
        /// @solidity memory-safe-assembly
9237
        assembly {
9238
            mstore(0x00, m0)
9239
            mstore(0x20, m1)
9240
            mstore(0x40, m2)
9241
            mstore(0x60, m3)
9242
            mstore(0x80, m4)
9243
            mstore(0xa0, m5)
9244
            mstore(0xc0, m6)
9245
        }
9246
    }
9247

                            
                        
9248
    function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
9249
        bytes32 m0;
9250
        bytes32 m1;
9251
        bytes32 m2;
9252
        bytes32 m3;
9253
        bytes32 m4;
9254
        bytes32 m5;
9255
        bytes32 m6;
9256
        /// @solidity memory-safe-assembly
9257
        assembly {
9258
            function writeString(pos, w) {
9259
                let length := 0
9260
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9261
                mstore(pos, length)
9262
                let shift := sub(256, shl(3, length))
9263
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9264
            }
9265
            m0 := mload(0x00)
9266
            m1 := mload(0x20)
9267
            m2 := mload(0x40)
9268
            m3 := mload(0x60)
9269
            m4 := mload(0x80)
9270
            m5 := mload(0xa0)
9271
            m6 := mload(0xc0)
9272
            // Selector of `log(uint256,bool,string,uint256)`.
9273
            mstore(0x00, 0x2c1d0746)
9274
            mstore(0x20, p0)
9275
            mstore(0x40, p1)
9276
            mstore(0x60, 0x80)
9277
            mstore(0x80, p3)
9278
            writeString(0xa0, p2)
9279
        }
9280
        _sendLogPayload(0x1c, 0xc4);
9281
        /// @solidity memory-safe-assembly
9282
        assembly {
9283
            mstore(0x00, m0)
9284
            mstore(0x20, m1)
9285
            mstore(0x40, m2)
9286
            mstore(0x60, m3)
9287
            mstore(0x80, m4)
9288
            mstore(0xa0, m5)
9289
            mstore(0xc0, m6)
9290
        }
9291
    }
9292

                            
                        
9293
    function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
9294
        bytes32 m0;
9295
        bytes32 m1;
9296
        bytes32 m2;
9297
        bytes32 m3;
9298
        bytes32 m4;
9299
        bytes32 m5;
9300
        bytes32 m6;
9301
        bytes32 m7;
9302
        bytes32 m8;
9303
        /// @solidity memory-safe-assembly
9304
        assembly {
9305
            function writeString(pos, w) {
9306
                let length := 0
9307
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9308
                mstore(pos, length)
9309
                let shift := sub(256, shl(3, length))
9310
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9311
            }
9312
            m0 := mload(0x00)
9313
            m1 := mload(0x20)
9314
            m2 := mload(0x40)
9315
            m3 := mload(0x60)
9316
            m4 := mload(0x80)
9317
            m5 := mload(0xa0)
9318
            m6 := mload(0xc0)
9319
            m7 := mload(0xe0)
9320
            m8 := mload(0x100)
9321
            // Selector of `log(uint256,bool,string,string)`.
9322
            mstore(0x00, 0x68c8b8bd)
9323
            mstore(0x20, p0)
9324
            mstore(0x40, p1)
9325
            mstore(0x60, 0x80)
9326
            mstore(0x80, 0xc0)
9327
            writeString(0xa0, p2)
9328
            writeString(0xe0, p3)
9329
        }
9330
        _sendLogPayload(0x1c, 0x104);
9331
        /// @solidity memory-safe-assembly
9332
        assembly {
9333
            mstore(0x00, m0)
9334
            mstore(0x20, m1)
9335
            mstore(0x40, m2)
9336
            mstore(0x60, m3)
9337
            mstore(0x80, m4)
9338
            mstore(0xa0, m5)
9339
            mstore(0xc0, m6)
9340
            mstore(0xe0, m7)
9341
            mstore(0x100, m8)
9342
        }
9343
    }
9344

                            
                        
9345
    function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
9346
        bytes32 m0;
9347
        bytes32 m1;
9348
        bytes32 m2;
9349
        bytes32 m3;
9350
        bytes32 m4;
9351
        /// @solidity memory-safe-assembly
9352
        assembly {
9353
            m0 := mload(0x00)
9354
            m1 := mload(0x20)
9355
            m2 := mload(0x40)
9356
            m3 := mload(0x60)
9357
            m4 := mload(0x80)
9358
            // Selector of `log(uint256,uint256,address,address)`.
9359
            mstore(0x00, 0x56a5d1b1)
9360
            mstore(0x20, p0)
9361
            mstore(0x40, p1)
9362
            mstore(0x60, p2)
9363
            mstore(0x80, p3)
9364
        }
9365
        _sendLogPayload(0x1c, 0x84);
9366
        /// @solidity memory-safe-assembly
9367
        assembly {
9368
            mstore(0x00, m0)
9369
            mstore(0x20, m1)
9370
            mstore(0x40, m2)
9371
            mstore(0x60, m3)
9372
            mstore(0x80, m4)
9373
        }
9374
    }
9375

                            
                        
9376
    function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
9377
        bytes32 m0;
9378
        bytes32 m1;
9379
        bytes32 m2;
9380
        bytes32 m3;
9381
        bytes32 m4;
9382
        /// @solidity memory-safe-assembly
9383
        assembly {
9384
            m0 := mload(0x00)
9385
            m1 := mload(0x20)
9386
            m2 := mload(0x40)
9387
            m3 := mload(0x60)
9388
            m4 := mload(0x80)
9389
            // Selector of `log(uint256,uint256,address,bool)`.
9390
            mstore(0x00, 0x15cac476)
9391
            mstore(0x20, p0)
9392
            mstore(0x40, p1)
9393
            mstore(0x60, p2)
9394
            mstore(0x80, p3)
9395
        }
9396
        _sendLogPayload(0x1c, 0x84);
9397
        /// @solidity memory-safe-assembly
9398
        assembly {
9399
            mstore(0x00, m0)
9400
            mstore(0x20, m1)
9401
            mstore(0x40, m2)
9402
            mstore(0x60, m3)
9403
            mstore(0x80, m4)
9404
        }
9405
    }
9406

                            
                        
9407
    function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
9408
        bytes32 m0;
9409
        bytes32 m1;
9410
        bytes32 m2;
9411
        bytes32 m3;
9412
        bytes32 m4;
9413
        /// @solidity memory-safe-assembly
9414
        assembly {
9415
            m0 := mload(0x00)
9416
            m1 := mload(0x20)
9417
            m2 := mload(0x40)
9418
            m3 := mload(0x60)
9419
            m4 := mload(0x80)
9420
            // Selector of `log(uint256,uint256,address,uint256)`.
9421
            mstore(0x00, 0x88f6e4b2)
9422
            mstore(0x20, p0)
9423
            mstore(0x40, p1)
9424
            mstore(0x60, p2)
9425
            mstore(0x80, p3)
9426
        }
9427
        _sendLogPayload(0x1c, 0x84);
9428
        /// @solidity memory-safe-assembly
9429
        assembly {
9430
            mstore(0x00, m0)
9431
            mstore(0x20, m1)
9432
            mstore(0x40, m2)
9433
            mstore(0x60, m3)
9434
            mstore(0x80, m4)
9435
        }
9436
    }
9437

                            
                        
9438
    function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {
9439
        bytes32 m0;
9440
        bytes32 m1;
9441
        bytes32 m2;
9442
        bytes32 m3;
9443
        bytes32 m4;
9444
        bytes32 m5;
9445
        bytes32 m6;
9446
        /// @solidity memory-safe-assembly
9447
        assembly {
9448
            function writeString(pos, w) {
9449
                let length := 0
9450
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9451
                mstore(pos, length)
9452
                let shift := sub(256, shl(3, length))
9453
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9454
            }
9455
            m0 := mload(0x00)
9456
            m1 := mload(0x20)
9457
            m2 := mload(0x40)
9458
            m3 := mload(0x60)
9459
            m4 := mload(0x80)
9460
            m5 := mload(0xa0)
9461
            m6 := mload(0xc0)
9462
            // Selector of `log(uint256,uint256,address,string)`.
9463
            mstore(0x00, 0x6cde40b8)
9464
            mstore(0x20, p0)
9465
            mstore(0x40, p1)
9466
            mstore(0x60, p2)
9467
            mstore(0x80, 0x80)
9468
            writeString(0xa0, p3)
9469
        }
9470
        _sendLogPayload(0x1c, 0xc4);
9471
        /// @solidity memory-safe-assembly
9472
        assembly {
9473
            mstore(0x00, m0)
9474
            mstore(0x20, m1)
9475
            mstore(0x40, m2)
9476
            mstore(0x60, m3)
9477
            mstore(0x80, m4)
9478
            mstore(0xa0, m5)
9479
            mstore(0xc0, m6)
9480
        }
9481
    }
9482

                            
                        
9483
    function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
9484
        bytes32 m0;
9485
        bytes32 m1;
9486
        bytes32 m2;
9487
        bytes32 m3;
9488
        bytes32 m4;
9489
        /// @solidity memory-safe-assembly
9490
        assembly {
9491
            m0 := mload(0x00)
9492
            m1 := mload(0x20)
9493
            m2 := mload(0x40)
9494
            m3 := mload(0x60)
9495
            m4 := mload(0x80)
9496
            // Selector of `log(uint256,uint256,bool,address)`.
9497
            mstore(0x00, 0x9a816a83)
9498
            mstore(0x20, p0)
9499
            mstore(0x40, p1)
9500
            mstore(0x60, p2)
9501
            mstore(0x80, p3)
9502
        }
9503
        _sendLogPayload(0x1c, 0x84);
9504
        /// @solidity memory-safe-assembly
9505
        assembly {
9506
            mstore(0x00, m0)
9507
            mstore(0x20, m1)
9508
            mstore(0x40, m2)
9509
            mstore(0x60, m3)
9510
            mstore(0x80, m4)
9511
        }
9512
    }
9513

                            
                        
9514
    function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
9515
        bytes32 m0;
9516
        bytes32 m1;
9517
        bytes32 m2;
9518
        bytes32 m3;
9519
        bytes32 m4;
9520
        /// @solidity memory-safe-assembly
9521
        assembly {
9522
            m0 := mload(0x00)
9523
            m1 := mload(0x20)
9524
            m2 := mload(0x40)
9525
            m3 := mload(0x60)
9526
            m4 := mload(0x80)
9527
            // Selector of `log(uint256,uint256,bool,bool)`.
9528
            mstore(0x00, 0xab085ae6)
9529
            mstore(0x20, p0)
9530
            mstore(0x40, p1)
9531
            mstore(0x60, p2)
9532
            mstore(0x80, p3)
9533
        }
9534
        _sendLogPayload(0x1c, 0x84);
9535
        /// @solidity memory-safe-assembly
9536
        assembly {
9537
            mstore(0x00, m0)
9538
            mstore(0x20, m1)
9539
            mstore(0x40, m2)
9540
            mstore(0x60, m3)
9541
            mstore(0x80, m4)
9542
        }
9543
    }
9544

                            
                        
9545
    function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
9546
        bytes32 m0;
9547
        bytes32 m1;
9548
        bytes32 m2;
9549
        bytes32 m3;
9550
        bytes32 m4;
9551
        /// @solidity memory-safe-assembly
9552
        assembly {
9553
            m0 := mload(0x00)
9554
            m1 := mload(0x20)
9555
            m2 := mload(0x40)
9556
            m3 := mload(0x60)
9557
            m4 := mload(0x80)
9558
            // Selector of `log(uint256,uint256,bool,uint256)`.
9559
            mstore(0x00, 0xeb7f6fd2)
9560
            mstore(0x20, p0)
9561
            mstore(0x40, p1)
9562
            mstore(0x60, p2)
9563
            mstore(0x80, p3)
9564
        }
9565
        _sendLogPayload(0x1c, 0x84);
9566
        /// @solidity memory-safe-assembly
9567
        assembly {
9568
            mstore(0x00, m0)
9569
            mstore(0x20, m1)
9570
            mstore(0x40, m2)
9571
            mstore(0x60, m3)
9572
            mstore(0x80, m4)
9573
        }
9574
    }
9575

                            
                        
9576
    function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
9577
        bytes32 m0;
9578
        bytes32 m1;
9579
        bytes32 m2;
9580
        bytes32 m3;
9581
        bytes32 m4;
9582
        bytes32 m5;
9583
        bytes32 m6;
9584
        /// @solidity memory-safe-assembly
9585
        assembly {
9586
            function writeString(pos, w) {
9587
                let length := 0
9588
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9589
                mstore(pos, length)
9590
                let shift := sub(256, shl(3, length))
9591
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9592
            }
9593
            m0 := mload(0x00)
9594
            m1 := mload(0x20)
9595
            m2 := mload(0x40)
9596
            m3 := mload(0x60)
9597
            m4 := mload(0x80)
9598
            m5 := mload(0xa0)
9599
            m6 := mload(0xc0)
9600
            // Selector of `log(uint256,uint256,bool,string)`.
9601
            mstore(0x00, 0xa5b4fc99)
9602
            mstore(0x20, p0)
9603
            mstore(0x40, p1)
9604
            mstore(0x60, p2)
9605
            mstore(0x80, 0x80)
9606
            writeString(0xa0, p3)
9607
        }
9608
        _sendLogPayload(0x1c, 0xc4);
9609
        /// @solidity memory-safe-assembly
9610
        assembly {
9611
            mstore(0x00, m0)
9612
            mstore(0x20, m1)
9613
            mstore(0x40, m2)
9614
            mstore(0x60, m3)
9615
            mstore(0x80, m4)
9616
            mstore(0xa0, m5)
9617
            mstore(0xc0, m6)
9618
        }
9619
    }
9620

                            
                        
9621
    function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
9622
        bytes32 m0;
9623
        bytes32 m1;
9624
        bytes32 m2;
9625
        bytes32 m3;
9626
        bytes32 m4;
9627
        /// @solidity memory-safe-assembly
9628
        assembly {
9629
            m0 := mload(0x00)
9630
            m1 := mload(0x20)
9631
            m2 := mload(0x40)
9632
            m3 := mload(0x60)
9633
            m4 := mload(0x80)
9634
            // Selector of `log(uint256,uint256,uint256,address)`.
9635
            mstore(0x00, 0xfa8185af)
9636
            mstore(0x20, p0)
9637
            mstore(0x40, p1)
9638
            mstore(0x60, p2)
9639
            mstore(0x80, p3)
9640
        }
9641
        _sendLogPayload(0x1c, 0x84);
9642
        /// @solidity memory-safe-assembly
9643
        assembly {
9644
            mstore(0x00, m0)
9645
            mstore(0x20, m1)
9646
            mstore(0x40, m2)
9647
            mstore(0x60, m3)
9648
            mstore(0x80, m4)
9649
        }
9650
    }
9651

                            
                        
9652
    function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
9653
        bytes32 m0;
9654
        bytes32 m1;
9655
        bytes32 m2;
9656
        bytes32 m3;
9657
        bytes32 m4;
9658
        /// @solidity memory-safe-assembly
9659
        assembly {
9660
            m0 := mload(0x00)
9661
            m1 := mload(0x20)
9662
            m2 := mload(0x40)
9663
            m3 := mload(0x60)
9664
            m4 := mload(0x80)
9665
            // Selector of `log(uint256,uint256,uint256,bool)`.
9666
            mstore(0x00, 0xc598d185)
9667
            mstore(0x20, p0)
9668
            mstore(0x40, p1)
9669
            mstore(0x60, p2)
9670
            mstore(0x80, p3)
9671
        }
9672
        _sendLogPayload(0x1c, 0x84);
9673
        /// @solidity memory-safe-assembly
9674
        assembly {
9675
            mstore(0x00, m0)
9676
            mstore(0x20, m1)
9677
            mstore(0x40, m2)
9678
            mstore(0x60, m3)
9679
            mstore(0x80, m4)
9680
        }
9681
    }
9682

                            
                        
9683
    function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
9684
        bytes32 m0;
9685
        bytes32 m1;
9686
        bytes32 m2;
9687
        bytes32 m3;
9688
        bytes32 m4;
9689
        /// @solidity memory-safe-assembly
9690
        assembly {
9691
            m0 := mload(0x00)
9692
            m1 := mload(0x20)
9693
            m2 := mload(0x40)
9694
            m3 := mload(0x60)
9695
            m4 := mload(0x80)
9696
            // Selector of `log(uint256,uint256,uint256,uint256)`.
9697
            mstore(0x00, 0x193fb800)
9698
            mstore(0x20, p0)
9699
            mstore(0x40, p1)
9700
            mstore(0x60, p2)
9701
            mstore(0x80, p3)
9702
        }
9703
        _sendLogPayload(0x1c, 0x84);
9704
        /// @solidity memory-safe-assembly
9705
        assembly {
9706
            mstore(0x00, m0)
9707
            mstore(0x20, m1)
9708
            mstore(0x40, m2)
9709
            mstore(0x60, m3)
9710
            mstore(0x80, m4)
9711
        }
9712
    }
9713

                            
                        
9714
    function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
9715
        bytes32 m0;
9716
        bytes32 m1;
9717
        bytes32 m2;
9718
        bytes32 m3;
9719
        bytes32 m4;
9720
        bytes32 m5;
9721
        bytes32 m6;
9722
        /// @solidity memory-safe-assembly
9723
        assembly {
9724
            function writeString(pos, w) {
9725
                let length := 0
9726
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9727
                mstore(pos, length)
9728
                let shift := sub(256, shl(3, length))
9729
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9730
            }
9731
            m0 := mload(0x00)
9732
            m1 := mload(0x20)
9733
            m2 := mload(0x40)
9734
            m3 := mload(0x60)
9735
            m4 := mload(0x80)
9736
            m5 := mload(0xa0)
9737
            m6 := mload(0xc0)
9738
            // Selector of `log(uint256,uint256,uint256,string)`.
9739
            mstore(0x00, 0x59cfcbe3)
9740
            mstore(0x20, p0)
9741
            mstore(0x40, p1)
9742
            mstore(0x60, p2)
9743
            mstore(0x80, 0x80)
9744
            writeString(0xa0, p3)
9745
        }
9746
        _sendLogPayload(0x1c, 0xc4);
9747
        /// @solidity memory-safe-assembly
9748
        assembly {
9749
            mstore(0x00, m0)
9750
            mstore(0x20, m1)
9751
            mstore(0x40, m2)
9752
            mstore(0x60, m3)
9753
            mstore(0x80, m4)
9754
            mstore(0xa0, m5)
9755
            mstore(0xc0, m6)
9756
        }
9757
    }
9758

                            
                        
9759
    function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {
9760
        bytes32 m0;
9761
        bytes32 m1;
9762
        bytes32 m2;
9763
        bytes32 m3;
9764
        bytes32 m4;
9765
        bytes32 m5;
9766
        bytes32 m6;
9767
        /// @solidity memory-safe-assembly
9768
        assembly {
9769
            function writeString(pos, w) {
9770
                let length := 0
9771
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9772
                mstore(pos, length)
9773
                let shift := sub(256, shl(3, length))
9774
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9775
            }
9776
            m0 := mload(0x00)
9777
            m1 := mload(0x20)
9778
            m2 := mload(0x40)
9779
            m3 := mload(0x60)
9780
            m4 := mload(0x80)
9781
            m5 := mload(0xa0)
9782
            m6 := mload(0xc0)
9783
            // Selector of `log(uint256,uint256,string,address)`.
9784
            mstore(0x00, 0x42d21db7)
9785
            mstore(0x20, p0)
9786
            mstore(0x40, p1)
9787
            mstore(0x60, 0x80)
9788
            mstore(0x80, p3)
9789
            writeString(0xa0, p2)
9790
        }
9791
        _sendLogPayload(0x1c, 0xc4);
9792
        /// @solidity memory-safe-assembly
9793
        assembly {
9794
            mstore(0x00, m0)
9795
            mstore(0x20, m1)
9796
            mstore(0x40, m2)
9797
            mstore(0x60, m3)
9798
            mstore(0x80, m4)
9799
            mstore(0xa0, m5)
9800
            mstore(0xc0, m6)
9801
        }
9802
    }
9803

                            
                        
9804
    function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
9805
        bytes32 m0;
9806
        bytes32 m1;
9807
        bytes32 m2;
9808
        bytes32 m3;
9809
        bytes32 m4;
9810
        bytes32 m5;
9811
        bytes32 m6;
9812
        /// @solidity memory-safe-assembly
9813
        assembly {
9814
            function writeString(pos, w) {
9815
                let length := 0
9816
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9817
                mstore(pos, length)
9818
                let shift := sub(256, shl(3, length))
9819
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9820
            }
9821
            m0 := mload(0x00)
9822
            m1 := mload(0x20)
9823
            m2 := mload(0x40)
9824
            m3 := mload(0x60)
9825
            m4 := mload(0x80)
9826
            m5 := mload(0xa0)
9827
            m6 := mload(0xc0)
9828
            // Selector of `log(uint256,uint256,string,bool)`.
9829
            mstore(0x00, 0x7af6ab25)
9830
            mstore(0x20, p0)
9831
            mstore(0x40, p1)
9832
            mstore(0x60, 0x80)
9833
            mstore(0x80, p3)
9834
            writeString(0xa0, p2)
9835
        }
9836
        _sendLogPayload(0x1c, 0xc4);
9837
        /// @solidity memory-safe-assembly
9838
        assembly {
9839
            mstore(0x00, m0)
9840
            mstore(0x20, m1)
9841
            mstore(0x40, m2)
9842
            mstore(0x60, m3)
9843
            mstore(0x80, m4)
9844
            mstore(0xa0, m5)
9845
            mstore(0xc0, m6)
9846
        }
9847
    }
9848

                            
                        
9849
    function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
9850
        bytes32 m0;
9851
        bytes32 m1;
9852
        bytes32 m2;
9853
        bytes32 m3;
9854
        bytes32 m4;
9855
        bytes32 m5;
9856
        bytes32 m6;
9857
        /// @solidity memory-safe-assembly
9858
        assembly {
9859
            function writeString(pos, w) {
9860
                let length := 0
9861
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9862
                mstore(pos, length)
9863
                let shift := sub(256, shl(3, length))
9864
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9865
            }
9866
            m0 := mload(0x00)
9867
            m1 := mload(0x20)
9868
            m2 := mload(0x40)
9869
            m3 := mload(0x60)
9870
            m4 := mload(0x80)
9871
            m5 := mload(0xa0)
9872
            m6 := mload(0xc0)
9873
            // Selector of `log(uint256,uint256,string,uint256)`.
9874
            mstore(0x00, 0x5da297eb)
9875
            mstore(0x20, p0)
9876
            mstore(0x40, p1)
9877
            mstore(0x60, 0x80)
9878
            mstore(0x80, p3)
9879
            writeString(0xa0, p2)
9880
        }
9881
        _sendLogPayload(0x1c, 0xc4);
9882
        /// @solidity memory-safe-assembly
9883
        assembly {
9884
            mstore(0x00, m0)
9885
            mstore(0x20, m1)
9886
            mstore(0x40, m2)
9887
            mstore(0x60, m3)
9888
            mstore(0x80, m4)
9889
            mstore(0xa0, m5)
9890
            mstore(0xc0, m6)
9891
        }
9892
    }
9893

                            
                        
9894
    function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
9895
        bytes32 m0;
9896
        bytes32 m1;
9897
        bytes32 m2;
9898
        bytes32 m3;
9899
        bytes32 m4;
9900
        bytes32 m5;
9901
        bytes32 m6;
9902
        bytes32 m7;
9903
        bytes32 m8;
9904
        /// @solidity memory-safe-assembly
9905
        assembly {
9906
            function writeString(pos, w) {
9907
                let length := 0
9908
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9909
                mstore(pos, length)
9910
                let shift := sub(256, shl(3, length))
9911
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9912
            }
9913
            m0 := mload(0x00)
9914
            m1 := mload(0x20)
9915
            m2 := mload(0x40)
9916
            m3 := mload(0x60)
9917
            m4 := mload(0x80)
9918
            m5 := mload(0xa0)
9919
            m6 := mload(0xc0)
9920
            m7 := mload(0xe0)
9921
            m8 := mload(0x100)
9922
            // Selector of `log(uint256,uint256,string,string)`.
9923
            mstore(0x00, 0x27d8afd2)
9924
            mstore(0x20, p0)
9925
            mstore(0x40, p1)
9926
            mstore(0x60, 0x80)
9927
            mstore(0x80, 0xc0)
9928
            writeString(0xa0, p2)
9929
            writeString(0xe0, p3)
9930
        }
9931
        _sendLogPayload(0x1c, 0x104);
9932
        /// @solidity memory-safe-assembly
9933
        assembly {
9934
            mstore(0x00, m0)
9935
            mstore(0x20, m1)
9936
            mstore(0x40, m2)
9937
            mstore(0x60, m3)
9938
            mstore(0x80, m4)
9939
            mstore(0xa0, m5)
9940
            mstore(0xc0, m6)
9941
            mstore(0xe0, m7)
9942
            mstore(0x100, m8)
9943
        }
9944
    }
9945

                            
                        
9946
    function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {
9947
        bytes32 m0;
9948
        bytes32 m1;
9949
        bytes32 m2;
9950
        bytes32 m3;
9951
        bytes32 m4;
9952
        bytes32 m5;
9953
        bytes32 m6;
9954
        /// @solidity memory-safe-assembly
9955
        assembly {
9956
            function writeString(pos, w) {
9957
                let length := 0
9958
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
9959
                mstore(pos, length)
9960
                let shift := sub(256, shl(3, length))
9961
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
9962
            }
9963
            m0 := mload(0x00)
9964
            m1 := mload(0x20)
9965
            m2 := mload(0x40)
9966
            m3 := mload(0x60)
9967
            m4 := mload(0x80)
9968
            m5 := mload(0xa0)
9969
            m6 := mload(0xc0)
9970
            // Selector of `log(uint256,string,address,address)`.
9971
            mstore(0x00, 0x6168ed61)
9972
            mstore(0x20, p0)
9973
            mstore(0x40, 0x80)
9974
            mstore(0x60, p2)
9975
            mstore(0x80, p3)
9976
            writeString(0xa0, p1)
9977
        }
9978
        _sendLogPayload(0x1c, 0xc4);
9979
        /// @solidity memory-safe-assembly
9980
        assembly {
9981
            mstore(0x00, m0)
9982
            mstore(0x20, m1)
9983
            mstore(0x40, m2)
9984
            mstore(0x60, m3)
9985
            mstore(0x80, m4)
9986
            mstore(0xa0, m5)
9987
            mstore(0xc0, m6)
9988
        }
9989
    }
9990

                            
                        
9991
    function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {
9992
        bytes32 m0;
9993
        bytes32 m1;
9994
        bytes32 m2;
9995
        bytes32 m3;
9996
        bytes32 m4;
9997
        bytes32 m5;
9998
        bytes32 m6;
9999
        /// @solidity memory-safe-assembly
10000
        assembly {
10001
            function writeString(pos, w) {
10002
                let length := 0
10003
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10004
                mstore(pos, length)
10005
                let shift := sub(256, shl(3, length))
10006
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10007
            }
10008
            m0 := mload(0x00)
10009
            m1 := mload(0x20)
10010
            m2 := mload(0x40)
10011
            m3 := mload(0x60)
10012
            m4 := mload(0x80)
10013
            m5 := mload(0xa0)
10014
            m6 := mload(0xc0)
10015
            // Selector of `log(uint256,string,address,bool)`.
10016
            mstore(0x00, 0x90c30a56)
10017
            mstore(0x20, p0)
10018
            mstore(0x40, 0x80)
10019
            mstore(0x60, p2)
10020
            mstore(0x80, p3)
10021
            writeString(0xa0, p1)
10022
        }
10023
        _sendLogPayload(0x1c, 0xc4);
10024
        /// @solidity memory-safe-assembly
10025
        assembly {
10026
            mstore(0x00, m0)
10027
            mstore(0x20, m1)
10028
            mstore(0x40, m2)
10029
            mstore(0x60, m3)
10030
            mstore(0x80, m4)
10031
            mstore(0xa0, m5)
10032
            mstore(0xc0, m6)
10033
        }
10034
    }
10035

                            
                        
10036
    function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {
10037
        bytes32 m0;
10038
        bytes32 m1;
10039
        bytes32 m2;
10040
        bytes32 m3;
10041
        bytes32 m4;
10042
        bytes32 m5;
10043
        bytes32 m6;
10044
        /// @solidity memory-safe-assembly
10045
        assembly {
10046
            function writeString(pos, w) {
10047
                let length := 0
10048
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10049
                mstore(pos, length)
10050
                let shift := sub(256, shl(3, length))
10051
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10052
            }
10053
            m0 := mload(0x00)
10054
            m1 := mload(0x20)
10055
            m2 := mload(0x40)
10056
            m3 := mload(0x60)
10057
            m4 := mload(0x80)
10058
            m5 := mload(0xa0)
10059
            m6 := mload(0xc0)
10060
            // Selector of `log(uint256,string,address,uint256)`.
10061
            mstore(0x00, 0xe8d3018d)
10062
            mstore(0x20, p0)
10063
            mstore(0x40, 0x80)
10064
            mstore(0x60, p2)
10065
            mstore(0x80, p3)
10066
            writeString(0xa0, p1)
10067
        }
10068
        _sendLogPayload(0x1c, 0xc4);
10069
        /// @solidity memory-safe-assembly
10070
        assembly {
10071
            mstore(0x00, m0)
10072
            mstore(0x20, m1)
10073
            mstore(0x40, m2)
10074
            mstore(0x60, m3)
10075
            mstore(0x80, m4)
10076
            mstore(0xa0, m5)
10077
            mstore(0xc0, m6)
10078
        }
10079
    }
10080

                            
                        
10081
    function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
10082
        bytes32 m0;
10083
        bytes32 m1;
10084
        bytes32 m2;
10085
        bytes32 m3;
10086
        bytes32 m4;
10087
        bytes32 m5;
10088
        bytes32 m6;
10089
        bytes32 m7;
10090
        bytes32 m8;
10091
        /// @solidity memory-safe-assembly
10092
        assembly {
10093
            function writeString(pos, w) {
10094
                let length := 0
10095
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10096
                mstore(pos, length)
10097
                let shift := sub(256, shl(3, length))
10098
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10099
            }
10100
            m0 := mload(0x00)
10101
            m1 := mload(0x20)
10102
            m2 := mload(0x40)
10103
            m3 := mload(0x60)
10104
            m4 := mload(0x80)
10105
            m5 := mload(0xa0)
10106
            m6 := mload(0xc0)
10107
            m7 := mload(0xe0)
10108
            m8 := mload(0x100)
10109
            // Selector of `log(uint256,string,address,string)`.
10110
            mstore(0x00, 0x9c3adfa1)
10111
            mstore(0x20, p0)
10112
            mstore(0x40, 0x80)
10113
            mstore(0x60, p2)
10114
            mstore(0x80, 0xc0)
10115
            writeString(0xa0, p1)
10116
            writeString(0xe0, p3)
10117
        }
10118
        _sendLogPayload(0x1c, 0x104);
10119
        /// @solidity memory-safe-assembly
10120
        assembly {
10121
            mstore(0x00, m0)
10122
            mstore(0x20, m1)
10123
            mstore(0x40, m2)
10124
            mstore(0x60, m3)
10125
            mstore(0x80, m4)
10126
            mstore(0xa0, m5)
10127
            mstore(0xc0, m6)
10128
            mstore(0xe0, m7)
10129
            mstore(0x100, m8)
10130
        }
10131
    }
10132

                            
                        
10133
    function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {
10134
        bytes32 m0;
10135
        bytes32 m1;
10136
        bytes32 m2;
10137
        bytes32 m3;
10138
        bytes32 m4;
10139
        bytes32 m5;
10140
        bytes32 m6;
10141
        /// @solidity memory-safe-assembly
10142
        assembly {
10143
            function writeString(pos, w) {
10144
                let length := 0
10145
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10146
                mstore(pos, length)
10147
                let shift := sub(256, shl(3, length))
10148
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10149
            }
10150
            m0 := mload(0x00)
10151
            m1 := mload(0x20)
10152
            m2 := mload(0x40)
10153
            m3 := mload(0x60)
10154
            m4 := mload(0x80)
10155
            m5 := mload(0xa0)
10156
            m6 := mload(0xc0)
10157
            // Selector of `log(uint256,string,bool,address)`.
10158
            mstore(0x00, 0xae2ec581)
10159
            mstore(0x20, p0)
10160
            mstore(0x40, 0x80)
10161
            mstore(0x60, p2)
10162
            mstore(0x80, p3)
10163
            writeString(0xa0, p1)
10164
        }
10165
        _sendLogPayload(0x1c, 0xc4);
10166
        /// @solidity memory-safe-assembly
10167
        assembly {
10168
            mstore(0x00, m0)
10169
            mstore(0x20, m1)
10170
            mstore(0x40, m2)
10171
            mstore(0x60, m3)
10172
            mstore(0x80, m4)
10173
            mstore(0xa0, m5)
10174
            mstore(0xc0, m6)
10175
        }
10176
    }
10177

                            
                        
10178
    function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {
10179
        bytes32 m0;
10180
        bytes32 m1;
10181
        bytes32 m2;
10182
        bytes32 m3;
10183
        bytes32 m4;
10184
        bytes32 m5;
10185
        bytes32 m6;
10186
        /// @solidity memory-safe-assembly
10187
        assembly {
10188
            function writeString(pos, w) {
10189
                let length := 0
10190
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10191
                mstore(pos, length)
10192
                let shift := sub(256, shl(3, length))
10193
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10194
            }
10195
            m0 := mload(0x00)
10196
            m1 := mload(0x20)
10197
            m2 := mload(0x40)
10198
            m3 := mload(0x60)
10199
            m4 := mload(0x80)
10200
            m5 := mload(0xa0)
10201
            m6 := mload(0xc0)
10202
            // Selector of `log(uint256,string,bool,bool)`.
10203
            mstore(0x00, 0xba535d9c)
10204
            mstore(0x20, p0)
10205
            mstore(0x40, 0x80)
10206
            mstore(0x60, p2)
10207
            mstore(0x80, p3)
10208
            writeString(0xa0, p1)
10209
        }
10210
        _sendLogPayload(0x1c, 0xc4);
10211
        /// @solidity memory-safe-assembly
10212
        assembly {
10213
            mstore(0x00, m0)
10214
            mstore(0x20, m1)
10215
            mstore(0x40, m2)
10216
            mstore(0x60, m3)
10217
            mstore(0x80, m4)
10218
            mstore(0xa0, m5)
10219
            mstore(0xc0, m6)
10220
        }
10221
    }
10222

                            
                        
10223
    function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
10224
        bytes32 m0;
10225
        bytes32 m1;
10226
        bytes32 m2;
10227
        bytes32 m3;
10228
        bytes32 m4;
10229
        bytes32 m5;
10230
        bytes32 m6;
10231
        /// @solidity memory-safe-assembly
10232
        assembly {
10233
            function writeString(pos, w) {
10234
                let length := 0
10235
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10236
                mstore(pos, length)
10237
                let shift := sub(256, shl(3, length))
10238
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10239
            }
10240
            m0 := mload(0x00)
10241
            m1 := mload(0x20)
10242
            m2 := mload(0x40)
10243
            m3 := mload(0x60)
10244
            m4 := mload(0x80)
10245
            m5 := mload(0xa0)
10246
            m6 := mload(0xc0)
10247
            // Selector of `log(uint256,string,bool,uint256)`.
10248
            mstore(0x00, 0xcf009880)
10249
            mstore(0x20, p0)
10250
            mstore(0x40, 0x80)
10251
            mstore(0x60, p2)
10252
            mstore(0x80, p3)
10253
            writeString(0xa0, p1)
10254
        }
10255
        _sendLogPayload(0x1c, 0xc4);
10256
        /// @solidity memory-safe-assembly
10257
        assembly {
10258
            mstore(0x00, m0)
10259
            mstore(0x20, m1)
10260
            mstore(0x40, m2)
10261
            mstore(0x60, m3)
10262
            mstore(0x80, m4)
10263
            mstore(0xa0, m5)
10264
            mstore(0xc0, m6)
10265
        }
10266
    }
10267

                            
                        
10268
    function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
10269
        bytes32 m0;
10270
        bytes32 m1;
10271
        bytes32 m2;
10272
        bytes32 m3;
10273
        bytes32 m4;
10274
        bytes32 m5;
10275
        bytes32 m6;
10276
        bytes32 m7;
10277
        bytes32 m8;
10278
        /// @solidity memory-safe-assembly
10279
        assembly {
10280
            function writeString(pos, w) {
10281
                let length := 0
10282
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10283
                mstore(pos, length)
10284
                let shift := sub(256, shl(3, length))
10285
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10286
            }
10287
            m0 := mload(0x00)
10288
            m1 := mload(0x20)
10289
            m2 := mload(0x40)
10290
            m3 := mload(0x60)
10291
            m4 := mload(0x80)
10292
            m5 := mload(0xa0)
10293
            m6 := mload(0xc0)
10294
            m7 := mload(0xe0)
10295
            m8 := mload(0x100)
10296
            // Selector of `log(uint256,string,bool,string)`.
10297
            mstore(0x00, 0xd2d423cd)
10298
            mstore(0x20, p0)
10299
            mstore(0x40, 0x80)
10300
            mstore(0x60, p2)
10301
            mstore(0x80, 0xc0)
10302
            writeString(0xa0, p1)
10303
            writeString(0xe0, p3)
10304
        }
10305
        _sendLogPayload(0x1c, 0x104);
10306
        /// @solidity memory-safe-assembly
10307
        assembly {
10308
            mstore(0x00, m0)
10309
            mstore(0x20, m1)
10310
            mstore(0x40, m2)
10311
            mstore(0x60, m3)
10312
            mstore(0x80, m4)
10313
            mstore(0xa0, m5)
10314
            mstore(0xc0, m6)
10315
            mstore(0xe0, m7)
10316
            mstore(0x100, m8)
10317
        }
10318
    }
10319

                            
                        
10320
    function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {
10321
        bytes32 m0;
10322
        bytes32 m1;
10323
        bytes32 m2;
10324
        bytes32 m3;
10325
        bytes32 m4;
10326
        bytes32 m5;
10327
        bytes32 m6;
10328
        /// @solidity memory-safe-assembly
10329
        assembly {
10330
            function writeString(pos, w) {
10331
                let length := 0
10332
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10333
                mstore(pos, length)
10334
                let shift := sub(256, shl(3, length))
10335
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10336
            }
10337
            m0 := mload(0x00)
10338
            m1 := mload(0x20)
10339
            m2 := mload(0x40)
10340
            m3 := mload(0x60)
10341
            m4 := mload(0x80)
10342
            m5 := mload(0xa0)
10343
            m6 := mload(0xc0)
10344
            // Selector of `log(uint256,string,uint256,address)`.
10345
            mstore(0x00, 0x3b2279b4)
10346
            mstore(0x20, p0)
10347
            mstore(0x40, 0x80)
10348
            mstore(0x60, p2)
10349
            mstore(0x80, p3)
10350
            writeString(0xa0, p1)
10351
        }
10352
        _sendLogPayload(0x1c, 0xc4);
10353
        /// @solidity memory-safe-assembly
10354
        assembly {
10355
            mstore(0x00, m0)
10356
            mstore(0x20, m1)
10357
            mstore(0x40, m2)
10358
            mstore(0x60, m3)
10359
            mstore(0x80, m4)
10360
            mstore(0xa0, m5)
10361
            mstore(0xc0, m6)
10362
        }
10363
    }
10364

                            
                        
10365
    function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
10366
        bytes32 m0;
10367
        bytes32 m1;
10368
        bytes32 m2;
10369
        bytes32 m3;
10370
        bytes32 m4;
10371
        bytes32 m5;
10372
        bytes32 m6;
10373
        /// @solidity memory-safe-assembly
10374
        assembly {
10375
            function writeString(pos, w) {
10376
                let length := 0
10377
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10378
                mstore(pos, length)
10379
                let shift := sub(256, shl(3, length))
10380
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10381
            }
10382
            m0 := mload(0x00)
10383
            m1 := mload(0x20)
10384
            m2 := mload(0x40)
10385
            m3 := mload(0x60)
10386
            m4 := mload(0x80)
10387
            m5 := mload(0xa0)
10388
            m6 := mload(0xc0)
10389
            // Selector of `log(uint256,string,uint256,bool)`.
10390
            mstore(0x00, 0x691a8f74)
10391
            mstore(0x20, p0)
10392
            mstore(0x40, 0x80)
10393
            mstore(0x60, p2)
10394
            mstore(0x80, p3)
10395
            writeString(0xa0, p1)
10396
        }
10397
        _sendLogPayload(0x1c, 0xc4);
10398
        /// @solidity memory-safe-assembly
10399
        assembly {
10400
            mstore(0x00, m0)
10401
            mstore(0x20, m1)
10402
            mstore(0x40, m2)
10403
            mstore(0x60, m3)
10404
            mstore(0x80, m4)
10405
            mstore(0xa0, m5)
10406
            mstore(0xc0, m6)
10407
        }
10408
    }
10409

                            
                        
10410
    function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
10411
        bytes32 m0;
10412
        bytes32 m1;
10413
        bytes32 m2;
10414
        bytes32 m3;
10415
        bytes32 m4;
10416
        bytes32 m5;
10417
        bytes32 m6;
10418
        /// @solidity memory-safe-assembly
10419
        assembly {
10420
            function writeString(pos, w) {
10421
                let length := 0
10422
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10423
                mstore(pos, length)
10424
                let shift := sub(256, shl(3, length))
10425
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10426
            }
10427
            m0 := mload(0x00)
10428
            m1 := mload(0x20)
10429
            m2 := mload(0x40)
10430
            m3 := mload(0x60)
10431
            m4 := mload(0x80)
10432
            m5 := mload(0xa0)
10433
            m6 := mload(0xc0)
10434
            // Selector of `log(uint256,string,uint256,uint256)`.
10435
            mstore(0x00, 0x82c25b74)
10436
            mstore(0x20, p0)
10437
            mstore(0x40, 0x80)
10438
            mstore(0x60, p2)
10439
            mstore(0x80, p3)
10440
            writeString(0xa0, p1)
10441
        }
10442
        _sendLogPayload(0x1c, 0xc4);
10443
        /// @solidity memory-safe-assembly
10444
        assembly {
10445
            mstore(0x00, m0)
10446
            mstore(0x20, m1)
10447
            mstore(0x40, m2)
10448
            mstore(0x60, m3)
10449
            mstore(0x80, m4)
10450
            mstore(0xa0, m5)
10451
            mstore(0xc0, m6)
10452
        }
10453
    }
10454

                            
                        
10455
    function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
10456
        bytes32 m0;
10457
        bytes32 m1;
10458
        bytes32 m2;
10459
        bytes32 m3;
10460
        bytes32 m4;
10461
        bytes32 m5;
10462
        bytes32 m6;
10463
        bytes32 m7;
10464
        bytes32 m8;
10465
        /// @solidity memory-safe-assembly
10466
        assembly {
10467
            function writeString(pos, w) {
10468
                let length := 0
10469
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10470
                mstore(pos, length)
10471
                let shift := sub(256, shl(3, length))
10472
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10473
            }
10474
            m0 := mload(0x00)
10475
            m1 := mload(0x20)
10476
            m2 := mload(0x40)
10477
            m3 := mload(0x60)
10478
            m4 := mload(0x80)
10479
            m5 := mload(0xa0)
10480
            m6 := mload(0xc0)
10481
            m7 := mload(0xe0)
10482
            m8 := mload(0x100)
10483
            // Selector of `log(uint256,string,uint256,string)`.
10484
            mstore(0x00, 0xb7b914ca)
10485
            mstore(0x20, p0)
10486
            mstore(0x40, 0x80)
10487
            mstore(0x60, p2)
10488
            mstore(0x80, 0xc0)
10489
            writeString(0xa0, p1)
10490
            writeString(0xe0, p3)
10491
        }
10492
        _sendLogPayload(0x1c, 0x104);
10493
        /// @solidity memory-safe-assembly
10494
        assembly {
10495
            mstore(0x00, m0)
10496
            mstore(0x20, m1)
10497
            mstore(0x40, m2)
10498
            mstore(0x60, m3)
10499
            mstore(0x80, m4)
10500
            mstore(0xa0, m5)
10501
            mstore(0xc0, m6)
10502
            mstore(0xe0, m7)
10503
            mstore(0x100, m8)
10504
        }
10505
    }
10506

                            
                        
10507
    function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
10508
        bytes32 m0;
10509
        bytes32 m1;
10510
        bytes32 m2;
10511
        bytes32 m3;
10512
        bytes32 m4;
10513
        bytes32 m5;
10514
        bytes32 m6;
10515
        bytes32 m7;
10516
        bytes32 m8;
10517
        /// @solidity memory-safe-assembly
10518
        assembly {
10519
            function writeString(pos, w) {
10520
                let length := 0
10521
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10522
                mstore(pos, length)
10523
                let shift := sub(256, shl(3, length))
10524
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10525
            }
10526
            m0 := mload(0x00)
10527
            m1 := mload(0x20)
10528
            m2 := mload(0x40)
10529
            m3 := mload(0x60)
10530
            m4 := mload(0x80)
10531
            m5 := mload(0xa0)
10532
            m6 := mload(0xc0)
10533
            m7 := mload(0xe0)
10534
            m8 := mload(0x100)
10535
            // Selector of `log(uint256,string,string,address)`.
10536
            mstore(0x00, 0xd583c602)
10537
            mstore(0x20, p0)
10538
            mstore(0x40, 0x80)
10539
            mstore(0x60, 0xc0)
10540
            mstore(0x80, p3)
10541
            writeString(0xa0, p1)
10542
            writeString(0xe0, p2)
10543
        }
10544
        _sendLogPayload(0x1c, 0x104);
10545
        /// @solidity memory-safe-assembly
10546
        assembly {
10547
            mstore(0x00, m0)
10548
            mstore(0x20, m1)
10549
            mstore(0x40, m2)
10550
            mstore(0x60, m3)
10551
            mstore(0x80, m4)
10552
            mstore(0xa0, m5)
10553
            mstore(0xc0, m6)
10554
            mstore(0xe0, m7)
10555
            mstore(0x100, m8)
10556
        }
10557
    }
10558

                            
                        
10559
    function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
10560
        bytes32 m0;
10561
        bytes32 m1;
10562
        bytes32 m2;
10563
        bytes32 m3;
10564
        bytes32 m4;
10565
        bytes32 m5;
10566
        bytes32 m6;
10567
        bytes32 m7;
10568
        bytes32 m8;
10569
        /// @solidity memory-safe-assembly
10570
        assembly {
10571
            function writeString(pos, w) {
10572
                let length := 0
10573
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10574
                mstore(pos, length)
10575
                let shift := sub(256, shl(3, length))
10576
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10577
            }
10578
            m0 := mload(0x00)
10579
            m1 := mload(0x20)
10580
            m2 := mload(0x40)
10581
            m3 := mload(0x60)
10582
            m4 := mload(0x80)
10583
            m5 := mload(0xa0)
10584
            m6 := mload(0xc0)
10585
            m7 := mload(0xe0)
10586
            m8 := mload(0x100)
10587
            // Selector of `log(uint256,string,string,bool)`.
10588
            mstore(0x00, 0xb3a6b6bd)
10589
            mstore(0x20, p0)
10590
            mstore(0x40, 0x80)
10591
            mstore(0x60, 0xc0)
10592
            mstore(0x80, p3)
10593
            writeString(0xa0, p1)
10594
            writeString(0xe0, p2)
10595
        }
10596
        _sendLogPayload(0x1c, 0x104);
10597
        /// @solidity memory-safe-assembly
10598
        assembly {
10599
            mstore(0x00, m0)
10600
            mstore(0x20, m1)
10601
            mstore(0x40, m2)
10602
            mstore(0x60, m3)
10603
            mstore(0x80, m4)
10604
            mstore(0xa0, m5)
10605
            mstore(0xc0, m6)
10606
            mstore(0xe0, m7)
10607
            mstore(0x100, m8)
10608
        }
10609
    }
10610

                            
                        
10611
    function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
10612
        bytes32 m0;
10613
        bytes32 m1;
10614
        bytes32 m2;
10615
        bytes32 m3;
10616
        bytes32 m4;
10617
        bytes32 m5;
10618
        bytes32 m6;
10619
        bytes32 m7;
10620
        bytes32 m8;
10621
        /// @solidity memory-safe-assembly
10622
        assembly {
10623
            function writeString(pos, w) {
10624
                let length := 0
10625
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10626
                mstore(pos, length)
10627
                let shift := sub(256, shl(3, length))
10628
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10629
            }
10630
            m0 := mload(0x00)
10631
            m1 := mload(0x20)
10632
            m2 := mload(0x40)
10633
            m3 := mload(0x60)
10634
            m4 := mload(0x80)
10635
            m5 := mload(0xa0)
10636
            m6 := mload(0xc0)
10637
            m7 := mload(0xe0)
10638
            m8 := mload(0x100)
10639
            // Selector of `log(uint256,string,string,uint256)`.
10640
            mstore(0x00, 0xb028c9bd)
10641
            mstore(0x20, p0)
10642
            mstore(0x40, 0x80)
10643
            mstore(0x60, 0xc0)
10644
            mstore(0x80, p3)
10645
            writeString(0xa0, p1)
10646
            writeString(0xe0, p2)
10647
        }
10648
        _sendLogPayload(0x1c, 0x104);
10649
        /// @solidity memory-safe-assembly
10650
        assembly {
10651
            mstore(0x00, m0)
10652
            mstore(0x20, m1)
10653
            mstore(0x40, m2)
10654
            mstore(0x60, m3)
10655
            mstore(0x80, m4)
10656
            mstore(0xa0, m5)
10657
            mstore(0xc0, m6)
10658
            mstore(0xe0, m7)
10659
            mstore(0x100, m8)
10660
        }
10661
    }
10662

                            
                        
10663
    function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
10664
        bytes32 m0;
10665
        bytes32 m1;
10666
        bytes32 m2;
10667
        bytes32 m3;
10668
        bytes32 m4;
10669
        bytes32 m5;
10670
        bytes32 m6;
10671
        bytes32 m7;
10672
        bytes32 m8;
10673
        bytes32 m9;
10674
        bytes32 m10;
10675
        /// @solidity memory-safe-assembly
10676
        assembly {
10677
            function writeString(pos, w) {
10678
                let length := 0
10679
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10680
                mstore(pos, length)
10681
                let shift := sub(256, shl(3, length))
10682
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10683
            }
10684
            m0 := mload(0x00)
10685
            m1 := mload(0x20)
10686
            m2 := mload(0x40)
10687
            m3 := mload(0x60)
10688
            m4 := mload(0x80)
10689
            m5 := mload(0xa0)
10690
            m6 := mload(0xc0)
10691
            m7 := mload(0xe0)
10692
            m8 := mload(0x100)
10693
            m9 := mload(0x120)
10694
            m10 := mload(0x140)
10695
            // Selector of `log(uint256,string,string,string)`.
10696
            mstore(0x00, 0x21ad0683)
10697
            mstore(0x20, p0)
10698
            mstore(0x40, 0x80)
10699
            mstore(0x60, 0xc0)
10700
            mstore(0x80, 0x100)
10701
            writeString(0xa0, p1)
10702
            writeString(0xe0, p2)
10703
            writeString(0x120, p3)
10704
        }
10705
        _sendLogPayload(0x1c, 0x144);
10706
        /// @solidity memory-safe-assembly
10707
        assembly {
10708
            mstore(0x00, m0)
10709
            mstore(0x20, m1)
10710
            mstore(0x40, m2)
10711
            mstore(0x60, m3)
10712
            mstore(0x80, m4)
10713
            mstore(0xa0, m5)
10714
            mstore(0xc0, m6)
10715
            mstore(0xe0, m7)
10716
            mstore(0x100, m8)
10717
            mstore(0x120, m9)
10718
            mstore(0x140, m10)
10719
        }
10720
    }
10721

                            
                        
10722
    function log(bytes32 p0, address p1, address p2, address p3) internal pure {
10723
        bytes32 m0;
10724
        bytes32 m1;
10725
        bytes32 m2;
10726
        bytes32 m3;
10727
        bytes32 m4;
10728
        bytes32 m5;
10729
        bytes32 m6;
10730
        /// @solidity memory-safe-assembly
10731
        assembly {
10732
            function writeString(pos, w) {
10733
                let length := 0
10734
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10735
                mstore(pos, length)
10736
                let shift := sub(256, shl(3, length))
10737
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10738
            }
10739
            m0 := mload(0x00)
10740
            m1 := mload(0x20)
10741
            m2 := mload(0x40)
10742
            m3 := mload(0x60)
10743
            m4 := mload(0x80)
10744
            m5 := mload(0xa0)
10745
            m6 := mload(0xc0)
10746
            // Selector of `log(string,address,address,address)`.
10747
            mstore(0x00, 0xed8f28f6)
10748
            mstore(0x20, 0x80)
10749
            mstore(0x40, p1)
10750
            mstore(0x60, p2)
10751
            mstore(0x80, p3)
10752
            writeString(0xa0, p0)
10753
        }
10754
        _sendLogPayload(0x1c, 0xc4);
10755
        /// @solidity memory-safe-assembly
10756
        assembly {
10757
            mstore(0x00, m0)
10758
            mstore(0x20, m1)
10759
            mstore(0x40, m2)
10760
            mstore(0x60, m3)
10761
            mstore(0x80, m4)
10762
            mstore(0xa0, m5)
10763
            mstore(0xc0, m6)
10764
        }
10765
    }
10766

                            
                        
10767
    function log(bytes32 p0, address p1, address p2, bool p3) internal pure {
10768
        bytes32 m0;
10769
        bytes32 m1;
10770
        bytes32 m2;
10771
        bytes32 m3;
10772
        bytes32 m4;
10773
        bytes32 m5;
10774
        bytes32 m6;
10775
        /// @solidity memory-safe-assembly
10776
        assembly {
10777
            function writeString(pos, w) {
10778
                let length := 0
10779
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10780
                mstore(pos, length)
10781
                let shift := sub(256, shl(3, length))
10782
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10783
            }
10784
            m0 := mload(0x00)
10785
            m1 := mload(0x20)
10786
            m2 := mload(0x40)
10787
            m3 := mload(0x60)
10788
            m4 := mload(0x80)
10789
            m5 := mload(0xa0)
10790
            m6 := mload(0xc0)
10791
            // Selector of `log(string,address,address,bool)`.
10792
            mstore(0x00, 0xb59dbd60)
10793
            mstore(0x20, 0x80)
10794
            mstore(0x40, p1)
10795
            mstore(0x60, p2)
10796
            mstore(0x80, p3)
10797
            writeString(0xa0, p0)
10798
        }
10799
        _sendLogPayload(0x1c, 0xc4);
10800
        /// @solidity memory-safe-assembly
10801
        assembly {
10802
            mstore(0x00, m0)
10803
            mstore(0x20, m1)
10804
            mstore(0x40, m2)
10805
            mstore(0x60, m3)
10806
            mstore(0x80, m4)
10807
            mstore(0xa0, m5)
10808
            mstore(0xc0, m6)
10809
        }
10810
    }
10811

                            
                        
10812
    function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {
10813
        bytes32 m0;
10814
        bytes32 m1;
10815
        bytes32 m2;
10816
        bytes32 m3;
10817
        bytes32 m4;
10818
        bytes32 m5;
10819
        bytes32 m6;
10820
        /// @solidity memory-safe-assembly
10821
        assembly {
10822
            function writeString(pos, w) {
10823
                let length := 0
10824
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10825
                mstore(pos, length)
10826
                let shift := sub(256, shl(3, length))
10827
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10828
            }
10829
            m0 := mload(0x00)
10830
            m1 := mload(0x20)
10831
            m2 := mload(0x40)
10832
            m3 := mload(0x60)
10833
            m4 := mload(0x80)
10834
            m5 := mload(0xa0)
10835
            m6 := mload(0xc0)
10836
            // Selector of `log(string,address,address,uint256)`.
10837
            mstore(0x00, 0x8ef3f399)
10838
            mstore(0x20, 0x80)
10839
            mstore(0x40, p1)
10840
            mstore(0x60, p2)
10841
            mstore(0x80, p3)
10842
            writeString(0xa0, p0)
10843
        }
10844
        _sendLogPayload(0x1c, 0xc4);
10845
        /// @solidity memory-safe-assembly
10846
        assembly {
10847
            mstore(0x00, m0)
10848
            mstore(0x20, m1)
10849
            mstore(0x40, m2)
10850
            mstore(0x60, m3)
10851
            mstore(0x80, m4)
10852
            mstore(0xa0, m5)
10853
            mstore(0xc0, m6)
10854
        }
10855
    }
10856

                            
                        
10857
    function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {
10858
        bytes32 m0;
10859
        bytes32 m1;
10860
        bytes32 m2;
10861
        bytes32 m3;
10862
        bytes32 m4;
10863
        bytes32 m5;
10864
        bytes32 m6;
10865
        bytes32 m7;
10866
        bytes32 m8;
10867
        /// @solidity memory-safe-assembly
10868
        assembly {
10869
            function writeString(pos, w) {
10870
                let length := 0
10871
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10872
                mstore(pos, length)
10873
                let shift := sub(256, shl(3, length))
10874
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10875
            }
10876
            m0 := mload(0x00)
10877
            m1 := mload(0x20)
10878
            m2 := mload(0x40)
10879
            m3 := mload(0x60)
10880
            m4 := mload(0x80)
10881
            m5 := mload(0xa0)
10882
            m6 := mload(0xc0)
10883
            m7 := mload(0xe0)
10884
            m8 := mload(0x100)
10885
            // Selector of `log(string,address,address,string)`.
10886
            mstore(0x00, 0x800a1c67)
10887
            mstore(0x20, 0x80)
10888
            mstore(0x40, p1)
10889
            mstore(0x60, p2)
10890
            mstore(0x80, 0xc0)
10891
            writeString(0xa0, p0)
10892
            writeString(0xe0, p3)
10893
        }
10894
        _sendLogPayload(0x1c, 0x104);
10895
        /// @solidity memory-safe-assembly
10896
        assembly {
10897
            mstore(0x00, m0)
10898
            mstore(0x20, m1)
10899
            mstore(0x40, m2)
10900
            mstore(0x60, m3)
10901
            mstore(0x80, m4)
10902
            mstore(0xa0, m5)
10903
            mstore(0xc0, m6)
10904
            mstore(0xe0, m7)
10905
            mstore(0x100, m8)
10906
        }
10907
    }
10908

                            
                        
10909
    function log(bytes32 p0, address p1, bool p2, address p3) internal pure {
10910
        bytes32 m0;
10911
        bytes32 m1;
10912
        bytes32 m2;
10913
        bytes32 m3;
10914
        bytes32 m4;
10915
        bytes32 m5;
10916
        bytes32 m6;
10917
        /// @solidity memory-safe-assembly
10918
        assembly {
10919
            function writeString(pos, w) {
10920
                let length := 0
10921
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10922
                mstore(pos, length)
10923
                let shift := sub(256, shl(3, length))
10924
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10925
            }
10926
            m0 := mload(0x00)
10927
            m1 := mload(0x20)
10928
            m2 := mload(0x40)
10929
            m3 := mload(0x60)
10930
            m4 := mload(0x80)
10931
            m5 := mload(0xa0)
10932
            m6 := mload(0xc0)
10933
            // Selector of `log(string,address,bool,address)`.
10934
            mstore(0x00, 0x223603bd)
10935
            mstore(0x20, 0x80)
10936
            mstore(0x40, p1)
10937
            mstore(0x60, p2)
10938
            mstore(0x80, p3)
10939
            writeString(0xa0, p0)
10940
        }
10941
        _sendLogPayload(0x1c, 0xc4);
10942
        /// @solidity memory-safe-assembly
10943
        assembly {
10944
            mstore(0x00, m0)
10945
            mstore(0x20, m1)
10946
            mstore(0x40, m2)
10947
            mstore(0x60, m3)
10948
            mstore(0x80, m4)
10949
            mstore(0xa0, m5)
10950
            mstore(0xc0, m6)
10951
        }
10952
    }
10953

                            
                        
10954
    function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {
10955
        bytes32 m0;
10956
        bytes32 m1;
10957
        bytes32 m2;
10958
        bytes32 m3;
10959
        bytes32 m4;
10960
        bytes32 m5;
10961
        bytes32 m6;
10962
        /// @solidity memory-safe-assembly
10963
        assembly {
10964
            function writeString(pos, w) {
10965
                let length := 0
10966
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
10967
                mstore(pos, length)
10968
                let shift := sub(256, shl(3, length))
10969
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
10970
            }
10971
            m0 := mload(0x00)
10972
            m1 := mload(0x20)
10973
            m2 := mload(0x40)
10974
            m3 := mload(0x60)
10975
            m4 := mload(0x80)
10976
            m5 := mload(0xa0)
10977
            m6 := mload(0xc0)
10978
            // Selector of `log(string,address,bool,bool)`.
10979
            mstore(0x00, 0x79884c2b)
10980
            mstore(0x20, 0x80)
10981
            mstore(0x40, p1)
10982
            mstore(0x60, p2)
10983
            mstore(0x80, p3)
10984
            writeString(0xa0, p0)
10985
        }
10986
        _sendLogPayload(0x1c, 0xc4);
10987
        /// @solidity memory-safe-assembly
10988
        assembly {
10989
            mstore(0x00, m0)
10990
            mstore(0x20, m1)
10991
            mstore(0x40, m2)
10992
            mstore(0x60, m3)
10993
            mstore(0x80, m4)
10994
            mstore(0xa0, m5)
10995
            mstore(0xc0, m6)
10996
        }
10997
    }
10998

                            
                        
10999
    function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {
11000
        bytes32 m0;
11001
        bytes32 m1;
11002
        bytes32 m2;
11003
        bytes32 m3;
11004
        bytes32 m4;
11005
        bytes32 m5;
11006
        bytes32 m6;
11007
        /// @solidity memory-safe-assembly
11008
        assembly {
11009
            function writeString(pos, w) {
11010
                let length := 0
11011
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11012
                mstore(pos, length)
11013
                let shift := sub(256, shl(3, length))
11014
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11015
            }
11016
            m0 := mload(0x00)
11017
            m1 := mload(0x20)
11018
            m2 := mload(0x40)
11019
            m3 := mload(0x60)
11020
            m4 := mload(0x80)
11021
            m5 := mload(0xa0)
11022
            m6 := mload(0xc0)
11023
            // Selector of `log(string,address,bool,uint256)`.
11024
            mstore(0x00, 0x3e9f866a)
11025
            mstore(0x20, 0x80)
11026
            mstore(0x40, p1)
11027
            mstore(0x60, p2)
11028
            mstore(0x80, p3)
11029
            writeString(0xa0, p0)
11030
        }
11031
        _sendLogPayload(0x1c, 0xc4);
11032
        /// @solidity memory-safe-assembly
11033
        assembly {
11034
            mstore(0x00, m0)
11035
            mstore(0x20, m1)
11036
            mstore(0x40, m2)
11037
            mstore(0x60, m3)
11038
            mstore(0x80, m4)
11039
            mstore(0xa0, m5)
11040
            mstore(0xc0, m6)
11041
        }
11042
    }
11043

                            
                        
11044
    function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {
11045
        bytes32 m0;
11046
        bytes32 m1;
11047
        bytes32 m2;
11048
        bytes32 m3;
11049
        bytes32 m4;
11050
        bytes32 m5;
11051
        bytes32 m6;
11052
        bytes32 m7;
11053
        bytes32 m8;
11054
        /// @solidity memory-safe-assembly
11055
        assembly {
11056
            function writeString(pos, w) {
11057
                let length := 0
11058
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11059
                mstore(pos, length)
11060
                let shift := sub(256, shl(3, length))
11061
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11062
            }
11063
            m0 := mload(0x00)
11064
            m1 := mload(0x20)
11065
            m2 := mload(0x40)
11066
            m3 := mload(0x60)
11067
            m4 := mload(0x80)
11068
            m5 := mload(0xa0)
11069
            m6 := mload(0xc0)
11070
            m7 := mload(0xe0)
11071
            m8 := mload(0x100)
11072
            // Selector of `log(string,address,bool,string)`.
11073
            mstore(0x00, 0x0454c079)
11074
            mstore(0x20, 0x80)
11075
            mstore(0x40, p1)
11076
            mstore(0x60, p2)
11077
            mstore(0x80, 0xc0)
11078
            writeString(0xa0, p0)
11079
            writeString(0xe0, p3)
11080
        }
11081
        _sendLogPayload(0x1c, 0x104);
11082
        /// @solidity memory-safe-assembly
11083
        assembly {
11084
            mstore(0x00, m0)
11085
            mstore(0x20, m1)
11086
            mstore(0x40, m2)
11087
            mstore(0x60, m3)
11088
            mstore(0x80, m4)
11089
            mstore(0xa0, m5)
11090
            mstore(0xc0, m6)
11091
            mstore(0xe0, m7)
11092
            mstore(0x100, m8)
11093
        }
11094
    }
11095

                            
                        
11096
    function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {
11097
        bytes32 m0;
11098
        bytes32 m1;
11099
        bytes32 m2;
11100
        bytes32 m3;
11101
        bytes32 m4;
11102
        bytes32 m5;
11103
        bytes32 m6;
11104
        /// @solidity memory-safe-assembly
11105
        assembly {
11106
            function writeString(pos, w) {
11107
                let length := 0
11108
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11109
                mstore(pos, length)
11110
                let shift := sub(256, shl(3, length))
11111
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11112
            }
11113
            m0 := mload(0x00)
11114
            m1 := mload(0x20)
11115
            m2 := mload(0x40)
11116
            m3 := mload(0x60)
11117
            m4 := mload(0x80)
11118
            m5 := mload(0xa0)
11119
            m6 := mload(0xc0)
11120
            // Selector of `log(string,address,uint256,address)`.
11121
            mstore(0x00, 0x63fb8bc5)
11122
            mstore(0x20, 0x80)
11123
            mstore(0x40, p1)
11124
            mstore(0x60, p2)
11125
            mstore(0x80, p3)
11126
            writeString(0xa0, p0)
11127
        }
11128
        _sendLogPayload(0x1c, 0xc4);
11129
        /// @solidity memory-safe-assembly
11130
        assembly {
11131
            mstore(0x00, m0)
11132
            mstore(0x20, m1)
11133
            mstore(0x40, m2)
11134
            mstore(0x60, m3)
11135
            mstore(0x80, m4)
11136
            mstore(0xa0, m5)
11137
            mstore(0xc0, m6)
11138
        }
11139
    }
11140

                            
                        
11141
    function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {
11142
        bytes32 m0;
11143
        bytes32 m1;
11144
        bytes32 m2;
11145
        bytes32 m3;
11146
        bytes32 m4;
11147
        bytes32 m5;
11148
        bytes32 m6;
11149
        /// @solidity memory-safe-assembly
11150
        assembly {
11151
            function writeString(pos, w) {
11152
                let length := 0
11153
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11154
                mstore(pos, length)
11155
                let shift := sub(256, shl(3, length))
11156
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11157
            }
11158
            m0 := mload(0x00)
11159
            m1 := mload(0x20)
11160
            m2 := mload(0x40)
11161
            m3 := mload(0x60)
11162
            m4 := mload(0x80)
11163
            m5 := mload(0xa0)
11164
            m6 := mload(0xc0)
11165
            // Selector of `log(string,address,uint256,bool)`.
11166
            mstore(0x00, 0xfc4845f0)
11167
            mstore(0x20, 0x80)
11168
            mstore(0x40, p1)
11169
            mstore(0x60, p2)
11170
            mstore(0x80, p3)
11171
            writeString(0xa0, p0)
11172
        }
11173
        _sendLogPayload(0x1c, 0xc4);
11174
        /// @solidity memory-safe-assembly
11175
        assembly {
11176
            mstore(0x00, m0)
11177
            mstore(0x20, m1)
11178
            mstore(0x40, m2)
11179
            mstore(0x60, m3)
11180
            mstore(0x80, m4)
11181
            mstore(0xa0, m5)
11182
            mstore(0xc0, m6)
11183
        }
11184
    }
11185

                            
                        
11186
    function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {
11187
        bytes32 m0;
11188
        bytes32 m1;
11189
        bytes32 m2;
11190
        bytes32 m3;
11191
        bytes32 m4;
11192
        bytes32 m5;
11193
        bytes32 m6;
11194
        /// @solidity memory-safe-assembly
11195
        assembly {
11196
            function writeString(pos, w) {
11197
                let length := 0
11198
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11199
                mstore(pos, length)
11200
                let shift := sub(256, shl(3, length))
11201
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11202
            }
11203
            m0 := mload(0x00)
11204
            m1 := mload(0x20)
11205
            m2 := mload(0x40)
11206
            m3 := mload(0x60)
11207
            m4 := mload(0x80)
11208
            m5 := mload(0xa0)
11209
            m6 := mload(0xc0)
11210
            // Selector of `log(string,address,uint256,uint256)`.
11211
            mstore(0x00, 0xf8f51b1e)
11212
            mstore(0x20, 0x80)
11213
            mstore(0x40, p1)
11214
            mstore(0x60, p2)
11215
            mstore(0x80, p3)
11216
            writeString(0xa0, p0)
11217
        }
11218
        _sendLogPayload(0x1c, 0xc4);
11219
        /// @solidity memory-safe-assembly
11220
        assembly {
11221
            mstore(0x00, m0)
11222
            mstore(0x20, m1)
11223
            mstore(0x40, m2)
11224
            mstore(0x60, m3)
11225
            mstore(0x80, m4)
11226
            mstore(0xa0, m5)
11227
            mstore(0xc0, m6)
11228
        }
11229
    }
11230

                            
                        
11231
    function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {
11232
        bytes32 m0;
11233
        bytes32 m1;
11234
        bytes32 m2;
11235
        bytes32 m3;
11236
        bytes32 m4;
11237
        bytes32 m5;
11238
        bytes32 m6;
11239
        bytes32 m7;
11240
        bytes32 m8;
11241
        /// @solidity memory-safe-assembly
11242
        assembly {
11243
            function writeString(pos, w) {
11244
                let length := 0
11245
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11246
                mstore(pos, length)
11247
                let shift := sub(256, shl(3, length))
11248
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11249
            }
11250
            m0 := mload(0x00)
11251
            m1 := mload(0x20)
11252
            m2 := mload(0x40)
11253
            m3 := mload(0x60)
11254
            m4 := mload(0x80)
11255
            m5 := mload(0xa0)
11256
            m6 := mload(0xc0)
11257
            m7 := mload(0xe0)
11258
            m8 := mload(0x100)
11259
            // Selector of `log(string,address,uint256,string)`.
11260
            mstore(0x00, 0x5a477632)
11261
            mstore(0x20, 0x80)
11262
            mstore(0x40, p1)
11263
            mstore(0x60, p2)
11264
            mstore(0x80, 0xc0)
11265
            writeString(0xa0, p0)
11266
            writeString(0xe0, p3)
11267
        }
11268
        _sendLogPayload(0x1c, 0x104);
11269
        /// @solidity memory-safe-assembly
11270
        assembly {
11271
            mstore(0x00, m0)
11272
            mstore(0x20, m1)
11273
            mstore(0x40, m2)
11274
            mstore(0x60, m3)
11275
            mstore(0x80, m4)
11276
            mstore(0xa0, m5)
11277
            mstore(0xc0, m6)
11278
            mstore(0xe0, m7)
11279
            mstore(0x100, m8)
11280
        }
11281
    }
11282

                            
                        
11283
    function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {
11284
        bytes32 m0;
11285
        bytes32 m1;
11286
        bytes32 m2;
11287
        bytes32 m3;
11288
        bytes32 m4;
11289
        bytes32 m5;
11290
        bytes32 m6;
11291
        bytes32 m7;
11292
        bytes32 m8;
11293
        /// @solidity memory-safe-assembly
11294
        assembly {
11295
            function writeString(pos, w) {
11296
                let length := 0
11297
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11298
                mstore(pos, length)
11299
                let shift := sub(256, shl(3, length))
11300
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11301
            }
11302
            m0 := mload(0x00)
11303
            m1 := mload(0x20)
11304
            m2 := mload(0x40)
11305
            m3 := mload(0x60)
11306
            m4 := mload(0x80)
11307
            m5 := mload(0xa0)
11308
            m6 := mload(0xc0)
11309
            m7 := mload(0xe0)
11310
            m8 := mload(0x100)
11311
            // Selector of `log(string,address,string,address)`.
11312
            mstore(0x00, 0xaabc9a31)
11313
            mstore(0x20, 0x80)
11314
            mstore(0x40, p1)
11315
            mstore(0x60, 0xc0)
11316
            mstore(0x80, p3)
11317
            writeString(0xa0, p0)
11318
            writeString(0xe0, p2)
11319
        }
11320
        _sendLogPayload(0x1c, 0x104);
11321
        /// @solidity memory-safe-assembly
11322
        assembly {
11323
            mstore(0x00, m0)
11324
            mstore(0x20, m1)
11325
            mstore(0x40, m2)
11326
            mstore(0x60, m3)
11327
            mstore(0x80, m4)
11328
            mstore(0xa0, m5)
11329
            mstore(0xc0, m6)
11330
            mstore(0xe0, m7)
11331
            mstore(0x100, m8)
11332
        }
11333
    }
11334

                            
                        
11335
    function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {
11336
        bytes32 m0;
11337
        bytes32 m1;
11338
        bytes32 m2;
11339
        bytes32 m3;
11340
        bytes32 m4;
11341
        bytes32 m5;
11342
        bytes32 m6;
11343
        bytes32 m7;
11344
        bytes32 m8;
11345
        /// @solidity memory-safe-assembly
11346
        assembly {
11347
            function writeString(pos, w) {
11348
                let length := 0
11349
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11350
                mstore(pos, length)
11351
                let shift := sub(256, shl(3, length))
11352
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11353
            }
11354
            m0 := mload(0x00)
11355
            m1 := mload(0x20)
11356
            m2 := mload(0x40)
11357
            m3 := mload(0x60)
11358
            m4 := mload(0x80)
11359
            m5 := mload(0xa0)
11360
            m6 := mload(0xc0)
11361
            m7 := mload(0xe0)
11362
            m8 := mload(0x100)
11363
            // Selector of `log(string,address,string,bool)`.
11364
            mstore(0x00, 0x5f15d28c)
11365
            mstore(0x20, 0x80)
11366
            mstore(0x40, p1)
11367
            mstore(0x60, 0xc0)
11368
            mstore(0x80, p3)
11369
            writeString(0xa0, p0)
11370
            writeString(0xe0, p2)
11371
        }
11372
        _sendLogPayload(0x1c, 0x104);
11373
        /// @solidity memory-safe-assembly
11374
        assembly {
11375
            mstore(0x00, m0)
11376
            mstore(0x20, m1)
11377
            mstore(0x40, m2)
11378
            mstore(0x60, m3)
11379
            mstore(0x80, m4)
11380
            mstore(0xa0, m5)
11381
            mstore(0xc0, m6)
11382
            mstore(0xe0, m7)
11383
            mstore(0x100, m8)
11384
        }
11385
    }
11386

                            
                        
11387
    function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {
11388
        bytes32 m0;
11389
        bytes32 m1;
11390
        bytes32 m2;
11391
        bytes32 m3;
11392
        bytes32 m4;
11393
        bytes32 m5;
11394
        bytes32 m6;
11395
        bytes32 m7;
11396
        bytes32 m8;
11397
        /// @solidity memory-safe-assembly
11398
        assembly {
11399
            function writeString(pos, w) {
11400
                let length := 0
11401
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11402
                mstore(pos, length)
11403
                let shift := sub(256, shl(3, length))
11404
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11405
            }
11406
            m0 := mload(0x00)
11407
            m1 := mload(0x20)
11408
            m2 := mload(0x40)
11409
            m3 := mload(0x60)
11410
            m4 := mload(0x80)
11411
            m5 := mload(0xa0)
11412
            m6 := mload(0xc0)
11413
            m7 := mload(0xe0)
11414
            m8 := mload(0x100)
11415
            // Selector of `log(string,address,string,uint256)`.
11416
            mstore(0x00, 0x91d1112e)
11417
            mstore(0x20, 0x80)
11418
            mstore(0x40, p1)
11419
            mstore(0x60, 0xc0)
11420
            mstore(0x80, p3)
11421
            writeString(0xa0, p0)
11422
            writeString(0xe0, p2)
11423
        }
11424
        _sendLogPayload(0x1c, 0x104);
11425
        /// @solidity memory-safe-assembly
11426
        assembly {
11427
            mstore(0x00, m0)
11428
            mstore(0x20, m1)
11429
            mstore(0x40, m2)
11430
            mstore(0x60, m3)
11431
            mstore(0x80, m4)
11432
            mstore(0xa0, m5)
11433
            mstore(0xc0, m6)
11434
            mstore(0xe0, m7)
11435
            mstore(0x100, m8)
11436
        }
11437
    }
11438

                            
                        
11439
    function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
11440
        bytes32 m0;
11441
        bytes32 m1;
11442
        bytes32 m2;
11443
        bytes32 m3;
11444
        bytes32 m4;
11445
        bytes32 m5;
11446
        bytes32 m6;
11447
        bytes32 m7;
11448
        bytes32 m8;
11449
        bytes32 m9;
11450
        bytes32 m10;
11451
        /// @solidity memory-safe-assembly
11452
        assembly {
11453
            function writeString(pos, w) {
11454
                let length := 0
11455
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11456
                mstore(pos, length)
11457
                let shift := sub(256, shl(3, length))
11458
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11459
            }
11460
            m0 := mload(0x00)
11461
            m1 := mload(0x20)
11462
            m2 := mload(0x40)
11463
            m3 := mload(0x60)
11464
            m4 := mload(0x80)
11465
            m5 := mload(0xa0)
11466
            m6 := mload(0xc0)
11467
            m7 := mload(0xe0)
11468
            m8 := mload(0x100)
11469
            m9 := mload(0x120)
11470
            m10 := mload(0x140)
11471
            // Selector of `log(string,address,string,string)`.
11472
            mstore(0x00, 0x245986f2)
11473
            mstore(0x20, 0x80)
11474
            mstore(0x40, p1)
11475
            mstore(0x60, 0xc0)
11476
            mstore(0x80, 0x100)
11477
            writeString(0xa0, p0)
11478
            writeString(0xe0, p2)
11479
            writeString(0x120, p3)
11480
        }
11481
        _sendLogPayload(0x1c, 0x144);
11482
        /// @solidity memory-safe-assembly
11483
        assembly {
11484
            mstore(0x00, m0)
11485
            mstore(0x20, m1)
11486
            mstore(0x40, m2)
11487
            mstore(0x60, m3)
11488
            mstore(0x80, m4)
11489
            mstore(0xa0, m5)
11490
            mstore(0xc0, m6)
11491
            mstore(0xe0, m7)
11492
            mstore(0x100, m8)
11493
            mstore(0x120, m9)
11494
            mstore(0x140, m10)
11495
        }
11496
    }
11497

                            
                        
11498
    function log(bytes32 p0, bool p1, address p2, address p3) internal pure {
11499
        bytes32 m0;
11500
        bytes32 m1;
11501
        bytes32 m2;
11502
        bytes32 m3;
11503
        bytes32 m4;
11504
        bytes32 m5;
11505
        bytes32 m6;
11506
        /// @solidity memory-safe-assembly
11507
        assembly {
11508
            function writeString(pos, w) {
11509
                let length := 0
11510
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11511
                mstore(pos, length)
11512
                let shift := sub(256, shl(3, length))
11513
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11514
            }
11515
            m0 := mload(0x00)
11516
            m1 := mload(0x20)
11517
            m2 := mload(0x40)
11518
            m3 := mload(0x60)
11519
            m4 := mload(0x80)
11520
            m5 := mload(0xa0)
11521
            m6 := mload(0xc0)
11522
            // Selector of `log(string,bool,address,address)`.
11523
            mstore(0x00, 0x33e9dd1d)
11524
            mstore(0x20, 0x80)
11525
            mstore(0x40, p1)
11526
            mstore(0x60, p2)
11527
            mstore(0x80, p3)
11528
            writeString(0xa0, p0)
11529
        }
11530
        _sendLogPayload(0x1c, 0xc4);
11531
        /// @solidity memory-safe-assembly
11532
        assembly {
11533
            mstore(0x00, m0)
11534
            mstore(0x20, m1)
11535
            mstore(0x40, m2)
11536
            mstore(0x60, m3)
11537
            mstore(0x80, m4)
11538
            mstore(0xa0, m5)
11539
            mstore(0xc0, m6)
11540
        }
11541
    }
11542

                            
                        
11543
    function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {
11544
        bytes32 m0;
11545
        bytes32 m1;
11546
        bytes32 m2;
11547
        bytes32 m3;
11548
        bytes32 m4;
11549
        bytes32 m5;
11550
        bytes32 m6;
11551
        /// @solidity memory-safe-assembly
11552
        assembly {
11553
            function writeString(pos, w) {
11554
                let length := 0
11555
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11556
                mstore(pos, length)
11557
                let shift := sub(256, shl(3, length))
11558
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11559
            }
11560
            m0 := mload(0x00)
11561
            m1 := mload(0x20)
11562
            m2 := mload(0x40)
11563
            m3 := mload(0x60)
11564
            m4 := mload(0x80)
11565
            m5 := mload(0xa0)
11566
            m6 := mload(0xc0)
11567
            // Selector of `log(string,bool,address,bool)`.
11568
            mstore(0x00, 0x958c28c6)
11569
            mstore(0x20, 0x80)
11570
            mstore(0x40, p1)
11571
            mstore(0x60, p2)
11572
            mstore(0x80, p3)
11573
            writeString(0xa0, p0)
11574
        }
11575
        _sendLogPayload(0x1c, 0xc4);
11576
        /// @solidity memory-safe-assembly
11577
        assembly {
11578
            mstore(0x00, m0)
11579
            mstore(0x20, m1)
11580
            mstore(0x40, m2)
11581
            mstore(0x60, m3)
11582
            mstore(0x80, m4)
11583
            mstore(0xa0, m5)
11584
            mstore(0xc0, m6)
11585
        }
11586
    }
11587

                            
                        
11588
    function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {
11589
        bytes32 m0;
11590
        bytes32 m1;
11591
        bytes32 m2;
11592
        bytes32 m3;
11593
        bytes32 m4;
11594
        bytes32 m5;
11595
        bytes32 m6;
11596
        /// @solidity memory-safe-assembly
11597
        assembly {
11598
            function writeString(pos, w) {
11599
                let length := 0
11600
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11601
                mstore(pos, length)
11602
                let shift := sub(256, shl(3, length))
11603
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11604
            }
11605
            m0 := mload(0x00)
11606
            m1 := mload(0x20)
11607
            m2 := mload(0x40)
11608
            m3 := mload(0x60)
11609
            m4 := mload(0x80)
11610
            m5 := mload(0xa0)
11611
            m6 := mload(0xc0)
11612
            // Selector of `log(string,bool,address,uint256)`.
11613
            mstore(0x00, 0x5d08bb05)
11614
            mstore(0x20, 0x80)
11615
            mstore(0x40, p1)
11616
            mstore(0x60, p2)
11617
            mstore(0x80, p3)
11618
            writeString(0xa0, p0)
11619
        }
11620
        _sendLogPayload(0x1c, 0xc4);
11621
        /// @solidity memory-safe-assembly
11622
        assembly {
11623
            mstore(0x00, m0)
11624
            mstore(0x20, m1)
11625
            mstore(0x40, m2)
11626
            mstore(0x60, m3)
11627
            mstore(0x80, m4)
11628
            mstore(0xa0, m5)
11629
            mstore(0xc0, m6)
11630
        }
11631
    }
11632

                            
                        
11633
    function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {
11634
        bytes32 m0;
11635
        bytes32 m1;
11636
        bytes32 m2;
11637
        bytes32 m3;
11638
        bytes32 m4;
11639
        bytes32 m5;
11640
        bytes32 m6;
11641
        bytes32 m7;
11642
        bytes32 m8;
11643
        /// @solidity memory-safe-assembly
11644
        assembly {
11645
            function writeString(pos, w) {
11646
                let length := 0
11647
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11648
                mstore(pos, length)
11649
                let shift := sub(256, shl(3, length))
11650
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11651
            }
11652
            m0 := mload(0x00)
11653
            m1 := mload(0x20)
11654
            m2 := mload(0x40)
11655
            m3 := mload(0x60)
11656
            m4 := mload(0x80)
11657
            m5 := mload(0xa0)
11658
            m6 := mload(0xc0)
11659
            m7 := mload(0xe0)
11660
            m8 := mload(0x100)
11661
            // Selector of `log(string,bool,address,string)`.
11662
            mstore(0x00, 0x2d8e33a4)
11663
            mstore(0x20, 0x80)
11664
            mstore(0x40, p1)
11665
            mstore(0x60, p2)
11666
            mstore(0x80, 0xc0)
11667
            writeString(0xa0, p0)
11668
            writeString(0xe0, p3)
11669
        }
11670
        _sendLogPayload(0x1c, 0x104);
11671
        /// @solidity memory-safe-assembly
11672
        assembly {
11673
            mstore(0x00, m0)
11674
            mstore(0x20, m1)
11675
            mstore(0x40, m2)
11676
            mstore(0x60, m3)
11677
            mstore(0x80, m4)
11678
            mstore(0xa0, m5)
11679
            mstore(0xc0, m6)
11680
            mstore(0xe0, m7)
11681
            mstore(0x100, m8)
11682
        }
11683
    }
11684

                            
                        
11685
    function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {
11686
        bytes32 m0;
11687
        bytes32 m1;
11688
        bytes32 m2;
11689
        bytes32 m3;
11690
        bytes32 m4;
11691
        bytes32 m5;
11692
        bytes32 m6;
11693
        /// @solidity memory-safe-assembly
11694
        assembly {
11695
            function writeString(pos, w) {
11696
                let length := 0
11697
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11698
                mstore(pos, length)
11699
                let shift := sub(256, shl(3, length))
11700
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11701
            }
11702
            m0 := mload(0x00)
11703
            m1 := mload(0x20)
11704
            m2 := mload(0x40)
11705
            m3 := mload(0x60)
11706
            m4 := mload(0x80)
11707
            m5 := mload(0xa0)
11708
            m6 := mload(0xc0)
11709
            // Selector of `log(string,bool,bool,address)`.
11710
            mstore(0x00, 0x7190a529)
11711
            mstore(0x20, 0x80)
11712
            mstore(0x40, p1)
11713
            mstore(0x60, p2)
11714
            mstore(0x80, p3)
11715
            writeString(0xa0, p0)
11716
        }
11717
        _sendLogPayload(0x1c, 0xc4);
11718
        /// @solidity memory-safe-assembly
11719
        assembly {
11720
            mstore(0x00, m0)
11721
            mstore(0x20, m1)
11722
            mstore(0x40, m2)
11723
            mstore(0x60, m3)
11724
            mstore(0x80, m4)
11725
            mstore(0xa0, m5)
11726
            mstore(0xc0, m6)
11727
        }
11728
    }
11729

                            
                        
11730
    function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {
11731
        bytes32 m0;
11732
        bytes32 m1;
11733
        bytes32 m2;
11734
        bytes32 m3;
11735
        bytes32 m4;
11736
        bytes32 m5;
11737
        bytes32 m6;
11738
        /// @solidity memory-safe-assembly
11739
        assembly {
11740
            function writeString(pos, w) {
11741
                let length := 0
11742
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11743
                mstore(pos, length)
11744
                let shift := sub(256, shl(3, length))
11745
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11746
            }
11747
            m0 := mload(0x00)
11748
            m1 := mload(0x20)
11749
            m2 := mload(0x40)
11750
            m3 := mload(0x60)
11751
            m4 := mload(0x80)
11752
            m5 := mload(0xa0)
11753
            m6 := mload(0xc0)
11754
            // Selector of `log(string,bool,bool,bool)`.
11755
            mstore(0x00, 0x895af8c5)
11756
            mstore(0x20, 0x80)
11757
            mstore(0x40, p1)
11758
            mstore(0x60, p2)
11759
            mstore(0x80, p3)
11760
            writeString(0xa0, p0)
11761
        }
11762
        _sendLogPayload(0x1c, 0xc4);
11763
        /// @solidity memory-safe-assembly
11764
        assembly {
11765
            mstore(0x00, m0)
11766
            mstore(0x20, m1)
11767
            mstore(0x40, m2)
11768
            mstore(0x60, m3)
11769
            mstore(0x80, m4)
11770
            mstore(0xa0, m5)
11771
            mstore(0xc0, m6)
11772
        }
11773
    }
11774

                            
                        
11775
    function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {
11776
        bytes32 m0;
11777
        bytes32 m1;
11778
        bytes32 m2;
11779
        bytes32 m3;
11780
        bytes32 m4;
11781
        bytes32 m5;
11782
        bytes32 m6;
11783
        /// @solidity memory-safe-assembly
11784
        assembly {
11785
            function writeString(pos, w) {
11786
                let length := 0
11787
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11788
                mstore(pos, length)
11789
                let shift := sub(256, shl(3, length))
11790
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11791
            }
11792
            m0 := mload(0x00)
11793
            m1 := mload(0x20)
11794
            m2 := mload(0x40)
11795
            m3 := mload(0x60)
11796
            m4 := mload(0x80)
11797
            m5 := mload(0xa0)
11798
            m6 := mload(0xc0)
11799
            // Selector of `log(string,bool,bool,uint256)`.
11800
            mstore(0x00, 0x8e3f78a9)
11801
            mstore(0x20, 0x80)
11802
            mstore(0x40, p1)
11803
            mstore(0x60, p2)
11804
            mstore(0x80, p3)
11805
            writeString(0xa0, p0)
11806
        }
11807
        _sendLogPayload(0x1c, 0xc4);
11808
        /// @solidity memory-safe-assembly
11809
        assembly {
11810
            mstore(0x00, m0)
11811
            mstore(0x20, m1)
11812
            mstore(0x40, m2)
11813
            mstore(0x60, m3)
11814
            mstore(0x80, m4)
11815
            mstore(0xa0, m5)
11816
            mstore(0xc0, m6)
11817
        }
11818
    }
11819

                            
                        
11820
    function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {
11821
        bytes32 m0;
11822
        bytes32 m1;
11823
        bytes32 m2;
11824
        bytes32 m3;
11825
        bytes32 m4;
11826
        bytes32 m5;
11827
        bytes32 m6;
11828
        bytes32 m7;
11829
        bytes32 m8;
11830
        /// @solidity memory-safe-assembly
11831
        assembly {
11832
            function writeString(pos, w) {
11833
                let length := 0
11834
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11835
                mstore(pos, length)
11836
                let shift := sub(256, shl(3, length))
11837
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11838
            }
11839
            m0 := mload(0x00)
11840
            m1 := mload(0x20)
11841
            m2 := mload(0x40)
11842
            m3 := mload(0x60)
11843
            m4 := mload(0x80)
11844
            m5 := mload(0xa0)
11845
            m6 := mload(0xc0)
11846
            m7 := mload(0xe0)
11847
            m8 := mload(0x100)
11848
            // Selector of `log(string,bool,bool,string)`.
11849
            mstore(0x00, 0x9d22d5dd)
11850
            mstore(0x20, 0x80)
11851
            mstore(0x40, p1)
11852
            mstore(0x60, p2)
11853
            mstore(0x80, 0xc0)
11854
            writeString(0xa0, p0)
11855
            writeString(0xe0, p3)
11856
        }
11857
        _sendLogPayload(0x1c, 0x104);
11858
        /// @solidity memory-safe-assembly
11859
        assembly {
11860
            mstore(0x00, m0)
11861
            mstore(0x20, m1)
11862
            mstore(0x40, m2)
11863
            mstore(0x60, m3)
11864
            mstore(0x80, m4)
11865
            mstore(0xa0, m5)
11866
            mstore(0xc0, m6)
11867
            mstore(0xe0, m7)
11868
            mstore(0x100, m8)
11869
        }
11870
    }
11871

                            
                        
11872
    function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {
11873
        bytes32 m0;
11874
        bytes32 m1;
11875
        bytes32 m2;
11876
        bytes32 m3;
11877
        bytes32 m4;
11878
        bytes32 m5;
11879
        bytes32 m6;
11880
        /// @solidity memory-safe-assembly
11881
        assembly {
11882
            function writeString(pos, w) {
11883
                let length := 0
11884
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11885
                mstore(pos, length)
11886
                let shift := sub(256, shl(3, length))
11887
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11888
            }
11889
            m0 := mload(0x00)
11890
            m1 := mload(0x20)
11891
            m2 := mload(0x40)
11892
            m3 := mload(0x60)
11893
            m4 := mload(0x80)
11894
            m5 := mload(0xa0)
11895
            m6 := mload(0xc0)
11896
            // Selector of `log(string,bool,uint256,address)`.
11897
            mstore(0x00, 0x935e09bf)
11898
            mstore(0x20, 0x80)
11899
            mstore(0x40, p1)
11900
            mstore(0x60, p2)
11901
            mstore(0x80, p3)
11902
            writeString(0xa0, p0)
11903
        }
11904
        _sendLogPayload(0x1c, 0xc4);
11905
        /// @solidity memory-safe-assembly
11906
        assembly {
11907
            mstore(0x00, m0)
11908
            mstore(0x20, m1)
11909
            mstore(0x40, m2)
11910
            mstore(0x60, m3)
11911
            mstore(0x80, m4)
11912
            mstore(0xa0, m5)
11913
            mstore(0xc0, m6)
11914
        }
11915
    }
11916

                            
                        
11917
    function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {
11918
        bytes32 m0;
11919
        bytes32 m1;
11920
        bytes32 m2;
11921
        bytes32 m3;
11922
        bytes32 m4;
11923
        bytes32 m5;
11924
        bytes32 m6;
11925
        /// @solidity memory-safe-assembly
11926
        assembly {
11927
            function writeString(pos, w) {
11928
                let length := 0
11929
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11930
                mstore(pos, length)
11931
                let shift := sub(256, shl(3, length))
11932
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11933
            }
11934
            m0 := mload(0x00)
11935
            m1 := mload(0x20)
11936
            m2 := mload(0x40)
11937
            m3 := mload(0x60)
11938
            m4 := mload(0x80)
11939
            m5 := mload(0xa0)
11940
            m6 := mload(0xc0)
11941
            // Selector of `log(string,bool,uint256,bool)`.
11942
            mstore(0x00, 0x8af7cf8a)
11943
            mstore(0x20, 0x80)
11944
            mstore(0x40, p1)
11945
            mstore(0x60, p2)
11946
            mstore(0x80, p3)
11947
            writeString(0xa0, p0)
11948
        }
11949
        _sendLogPayload(0x1c, 0xc4);
11950
        /// @solidity memory-safe-assembly
11951
        assembly {
11952
            mstore(0x00, m0)
11953
            mstore(0x20, m1)
11954
            mstore(0x40, m2)
11955
            mstore(0x60, m3)
11956
            mstore(0x80, m4)
11957
            mstore(0xa0, m5)
11958
            mstore(0xc0, m6)
11959
        }
11960
    }
11961

                            
                        
11962
    function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {
11963
        bytes32 m0;
11964
        bytes32 m1;
11965
        bytes32 m2;
11966
        bytes32 m3;
11967
        bytes32 m4;
11968
        bytes32 m5;
11969
        bytes32 m6;
11970
        /// @solidity memory-safe-assembly
11971
        assembly {
11972
            function writeString(pos, w) {
11973
                let length := 0
11974
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
11975
                mstore(pos, length)
11976
                let shift := sub(256, shl(3, length))
11977
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
11978
            }
11979
            m0 := mload(0x00)
11980
            m1 := mload(0x20)
11981
            m2 := mload(0x40)
11982
            m3 := mload(0x60)
11983
            m4 := mload(0x80)
11984
            m5 := mload(0xa0)
11985
            m6 := mload(0xc0)
11986
            // Selector of `log(string,bool,uint256,uint256)`.
11987
            mstore(0x00, 0x64b5bb67)
11988
            mstore(0x20, 0x80)
11989
            mstore(0x40, p1)
11990
            mstore(0x60, p2)
11991
            mstore(0x80, p3)
11992
            writeString(0xa0, p0)
11993
        }
11994
        _sendLogPayload(0x1c, 0xc4);
11995
        /// @solidity memory-safe-assembly
11996
        assembly {
11997
            mstore(0x00, m0)
11998
            mstore(0x20, m1)
11999
            mstore(0x40, m2)
12000
            mstore(0x60, m3)
12001
            mstore(0x80, m4)
12002
            mstore(0xa0, m5)
12003
            mstore(0xc0, m6)
12004
        }
12005
    }
12006

                            
                        
12007
    function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
12008
        bytes32 m0;
12009
        bytes32 m1;
12010
        bytes32 m2;
12011
        bytes32 m3;
12012
        bytes32 m4;
12013
        bytes32 m5;
12014
        bytes32 m6;
12015
        bytes32 m7;
12016
        bytes32 m8;
12017
        /// @solidity memory-safe-assembly
12018
        assembly {
12019
            function writeString(pos, w) {
12020
                let length := 0
12021
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12022
                mstore(pos, length)
12023
                let shift := sub(256, shl(3, length))
12024
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12025
            }
12026
            m0 := mload(0x00)
12027
            m1 := mload(0x20)
12028
            m2 := mload(0x40)
12029
            m3 := mload(0x60)
12030
            m4 := mload(0x80)
12031
            m5 := mload(0xa0)
12032
            m6 := mload(0xc0)
12033
            m7 := mload(0xe0)
12034
            m8 := mload(0x100)
12035
            // Selector of `log(string,bool,uint256,string)`.
12036
            mstore(0x00, 0x742d6ee7)
12037
            mstore(0x20, 0x80)
12038
            mstore(0x40, p1)
12039
            mstore(0x60, p2)
12040
            mstore(0x80, 0xc0)
12041
            writeString(0xa0, p0)
12042
            writeString(0xe0, p3)
12043
        }
12044
        _sendLogPayload(0x1c, 0x104);
12045
        /// @solidity memory-safe-assembly
12046
        assembly {
12047
            mstore(0x00, m0)
12048
            mstore(0x20, m1)
12049
            mstore(0x40, m2)
12050
            mstore(0x60, m3)
12051
            mstore(0x80, m4)
12052
            mstore(0xa0, m5)
12053
            mstore(0xc0, m6)
12054
            mstore(0xe0, m7)
12055
            mstore(0x100, m8)
12056
        }
12057
    }
12058

                            
                        
12059
    function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {
12060
        bytes32 m0;
12061
        bytes32 m1;
12062
        bytes32 m2;
12063
        bytes32 m3;
12064
        bytes32 m4;
12065
        bytes32 m5;
12066
        bytes32 m6;
12067
        bytes32 m7;
12068
        bytes32 m8;
12069
        /// @solidity memory-safe-assembly
12070
        assembly {
12071
            function writeString(pos, w) {
12072
                let length := 0
12073
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12074
                mstore(pos, length)
12075
                let shift := sub(256, shl(3, length))
12076
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12077
            }
12078
            m0 := mload(0x00)
12079
            m1 := mload(0x20)
12080
            m2 := mload(0x40)
12081
            m3 := mload(0x60)
12082
            m4 := mload(0x80)
12083
            m5 := mload(0xa0)
12084
            m6 := mload(0xc0)
12085
            m7 := mload(0xe0)
12086
            m8 := mload(0x100)
12087
            // Selector of `log(string,bool,string,address)`.
12088
            mstore(0x00, 0xe0625b29)
12089
            mstore(0x20, 0x80)
12090
            mstore(0x40, p1)
12091
            mstore(0x60, 0xc0)
12092
            mstore(0x80, p3)
12093
            writeString(0xa0, p0)
12094
            writeString(0xe0, p2)
12095
        }
12096
        _sendLogPayload(0x1c, 0x104);
12097
        /// @solidity memory-safe-assembly
12098
        assembly {
12099
            mstore(0x00, m0)
12100
            mstore(0x20, m1)
12101
            mstore(0x40, m2)
12102
            mstore(0x60, m3)
12103
            mstore(0x80, m4)
12104
            mstore(0xa0, m5)
12105
            mstore(0xc0, m6)
12106
            mstore(0xe0, m7)
12107
            mstore(0x100, m8)
12108
        }
12109
    }
12110

                            
                        
12111
    function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {
12112
        bytes32 m0;
12113
        bytes32 m1;
12114
        bytes32 m2;
12115
        bytes32 m3;
12116
        bytes32 m4;
12117
        bytes32 m5;
12118
        bytes32 m6;
12119
        bytes32 m7;
12120
        bytes32 m8;
12121
        /// @solidity memory-safe-assembly
12122
        assembly {
12123
            function writeString(pos, w) {
12124
                let length := 0
12125
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12126
                mstore(pos, length)
12127
                let shift := sub(256, shl(3, length))
12128
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12129
            }
12130
            m0 := mload(0x00)
12131
            m1 := mload(0x20)
12132
            m2 := mload(0x40)
12133
            m3 := mload(0x60)
12134
            m4 := mload(0x80)
12135
            m5 := mload(0xa0)
12136
            m6 := mload(0xc0)
12137
            m7 := mload(0xe0)
12138
            m8 := mload(0x100)
12139
            // Selector of `log(string,bool,string,bool)`.
12140
            mstore(0x00, 0x3f8a701d)
12141
            mstore(0x20, 0x80)
12142
            mstore(0x40, p1)
12143
            mstore(0x60, 0xc0)
12144
            mstore(0x80, p3)
12145
            writeString(0xa0, p0)
12146
            writeString(0xe0, p2)
12147
        }
12148
        _sendLogPayload(0x1c, 0x104);
12149
        /// @solidity memory-safe-assembly
12150
        assembly {
12151
            mstore(0x00, m0)
12152
            mstore(0x20, m1)
12153
            mstore(0x40, m2)
12154
            mstore(0x60, m3)
12155
            mstore(0x80, m4)
12156
            mstore(0xa0, m5)
12157
            mstore(0xc0, m6)
12158
            mstore(0xe0, m7)
12159
            mstore(0x100, m8)
12160
        }
12161
    }
12162

                            
                        
12163
    function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
12164
        bytes32 m0;
12165
        bytes32 m1;
12166
        bytes32 m2;
12167
        bytes32 m3;
12168
        bytes32 m4;
12169
        bytes32 m5;
12170
        bytes32 m6;
12171
        bytes32 m7;
12172
        bytes32 m8;
12173
        /// @solidity memory-safe-assembly
12174
        assembly {
12175
            function writeString(pos, w) {
12176
                let length := 0
12177
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12178
                mstore(pos, length)
12179
                let shift := sub(256, shl(3, length))
12180
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12181
            }
12182
            m0 := mload(0x00)
12183
            m1 := mload(0x20)
12184
            m2 := mload(0x40)
12185
            m3 := mload(0x60)
12186
            m4 := mload(0x80)
12187
            m5 := mload(0xa0)
12188
            m6 := mload(0xc0)
12189
            m7 := mload(0xe0)
12190
            m8 := mload(0x100)
12191
            // Selector of `log(string,bool,string,uint256)`.
12192
            mstore(0x00, 0x24f91465)
12193
            mstore(0x20, 0x80)
12194
            mstore(0x40, p1)
12195
            mstore(0x60, 0xc0)
12196
            mstore(0x80, p3)
12197
            writeString(0xa0, p0)
12198
            writeString(0xe0, p2)
12199
        }
12200
        _sendLogPayload(0x1c, 0x104);
12201
        /// @solidity memory-safe-assembly
12202
        assembly {
12203
            mstore(0x00, m0)
12204
            mstore(0x20, m1)
12205
            mstore(0x40, m2)
12206
            mstore(0x60, m3)
12207
            mstore(0x80, m4)
12208
            mstore(0xa0, m5)
12209
            mstore(0xc0, m6)
12210
            mstore(0xe0, m7)
12211
            mstore(0x100, m8)
12212
        }
12213
    }
12214

                            
                        
12215
    function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
12216
        bytes32 m0;
12217
        bytes32 m1;
12218
        bytes32 m2;
12219
        bytes32 m3;
12220
        bytes32 m4;
12221
        bytes32 m5;
12222
        bytes32 m6;
12223
        bytes32 m7;
12224
        bytes32 m8;
12225
        bytes32 m9;
12226
        bytes32 m10;
12227
        /// @solidity memory-safe-assembly
12228
        assembly {
12229
            function writeString(pos, w) {
12230
                let length := 0
12231
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12232
                mstore(pos, length)
12233
                let shift := sub(256, shl(3, length))
12234
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12235
            }
12236
            m0 := mload(0x00)
12237
            m1 := mload(0x20)
12238
            m2 := mload(0x40)
12239
            m3 := mload(0x60)
12240
            m4 := mload(0x80)
12241
            m5 := mload(0xa0)
12242
            m6 := mload(0xc0)
12243
            m7 := mload(0xe0)
12244
            m8 := mload(0x100)
12245
            m9 := mload(0x120)
12246
            m10 := mload(0x140)
12247
            // Selector of `log(string,bool,string,string)`.
12248
            mstore(0x00, 0xa826caeb)
12249
            mstore(0x20, 0x80)
12250
            mstore(0x40, p1)
12251
            mstore(0x60, 0xc0)
12252
            mstore(0x80, 0x100)
12253
            writeString(0xa0, p0)
12254
            writeString(0xe0, p2)
12255
            writeString(0x120, p3)
12256
        }
12257
        _sendLogPayload(0x1c, 0x144);
12258
        /// @solidity memory-safe-assembly
12259
        assembly {
12260
            mstore(0x00, m0)
12261
            mstore(0x20, m1)
12262
            mstore(0x40, m2)
12263
            mstore(0x60, m3)
12264
            mstore(0x80, m4)
12265
            mstore(0xa0, m5)
12266
            mstore(0xc0, m6)
12267
            mstore(0xe0, m7)
12268
            mstore(0x100, m8)
12269
            mstore(0x120, m9)
12270
            mstore(0x140, m10)
12271
        }
12272
    }
12273

                            
                        
12274
    function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {
12275
        bytes32 m0;
12276
        bytes32 m1;
12277
        bytes32 m2;
12278
        bytes32 m3;
12279
        bytes32 m4;
12280
        bytes32 m5;
12281
        bytes32 m6;
12282
        /// @solidity memory-safe-assembly
12283
        assembly {
12284
            function writeString(pos, w) {
12285
                let length := 0
12286
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12287
                mstore(pos, length)
12288
                let shift := sub(256, shl(3, length))
12289
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12290
            }
12291
            m0 := mload(0x00)
12292
            m1 := mload(0x20)
12293
            m2 := mload(0x40)
12294
            m3 := mload(0x60)
12295
            m4 := mload(0x80)
12296
            m5 := mload(0xa0)
12297
            m6 := mload(0xc0)
12298
            // Selector of `log(string,uint256,address,address)`.
12299
            mstore(0x00, 0x5ea2b7ae)
12300
            mstore(0x20, 0x80)
12301
            mstore(0x40, p1)
12302
            mstore(0x60, p2)
12303
            mstore(0x80, p3)
12304
            writeString(0xa0, p0)
12305
        }
12306
        _sendLogPayload(0x1c, 0xc4);
12307
        /// @solidity memory-safe-assembly
12308
        assembly {
12309
            mstore(0x00, m0)
12310
            mstore(0x20, m1)
12311
            mstore(0x40, m2)
12312
            mstore(0x60, m3)
12313
            mstore(0x80, m4)
12314
            mstore(0xa0, m5)
12315
            mstore(0xc0, m6)
12316
        }
12317
    }
12318

                            
                        
12319
    function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {
12320
        bytes32 m0;
12321
        bytes32 m1;
12322
        bytes32 m2;
12323
        bytes32 m3;
12324
        bytes32 m4;
12325
        bytes32 m5;
12326
        bytes32 m6;
12327
        /// @solidity memory-safe-assembly
12328
        assembly {
12329
            function writeString(pos, w) {
12330
                let length := 0
12331
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12332
                mstore(pos, length)
12333
                let shift := sub(256, shl(3, length))
12334
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12335
            }
12336
            m0 := mload(0x00)
12337
            m1 := mload(0x20)
12338
            m2 := mload(0x40)
12339
            m3 := mload(0x60)
12340
            m4 := mload(0x80)
12341
            m5 := mload(0xa0)
12342
            m6 := mload(0xc0)
12343
            // Selector of `log(string,uint256,address,bool)`.
12344
            mstore(0x00, 0x82112a42)
12345
            mstore(0x20, 0x80)
12346
            mstore(0x40, p1)
12347
            mstore(0x60, p2)
12348
            mstore(0x80, p3)
12349
            writeString(0xa0, p0)
12350
        }
12351
        _sendLogPayload(0x1c, 0xc4);
12352
        /// @solidity memory-safe-assembly
12353
        assembly {
12354
            mstore(0x00, m0)
12355
            mstore(0x20, m1)
12356
            mstore(0x40, m2)
12357
            mstore(0x60, m3)
12358
            mstore(0x80, m4)
12359
            mstore(0xa0, m5)
12360
            mstore(0xc0, m6)
12361
        }
12362
    }
12363

                            
                        
12364
    function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {
12365
        bytes32 m0;
12366
        bytes32 m1;
12367
        bytes32 m2;
12368
        bytes32 m3;
12369
        bytes32 m4;
12370
        bytes32 m5;
12371
        bytes32 m6;
12372
        /// @solidity memory-safe-assembly
12373
        assembly {
12374
            function writeString(pos, w) {
12375
                let length := 0
12376
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12377
                mstore(pos, length)
12378
                let shift := sub(256, shl(3, length))
12379
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12380
            }
12381
            m0 := mload(0x00)
12382
            m1 := mload(0x20)
12383
            m2 := mload(0x40)
12384
            m3 := mload(0x60)
12385
            m4 := mload(0x80)
12386
            m5 := mload(0xa0)
12387
            m6 := mload(0xc0)
12388
            // Selector of `log(string,uint256,address,uint256)`.
12389
            mstore(0x00, 0x4f04fdc6)
12390
            mstore(0x20, 0x80)
12391
            mstore(0x40, p1)
12392
            mstore(0x60, p2)
12393
            mstore(0x80, p3)
12394
            writeString(0xa0, p0)
12395
        }
12396
        _sendLogPayload(0x1c, 0xc4);
12397
        /// @solidity memory-safe-assembly
12398
        assembly {
12399
            mstore(0x00, m0)
12400
            mstore(0x20, m1)
12401
            mstore(0x40, m2)
12402
            mstore(0x60, m3)
12403
            mstore(0x80, m4)
12404
            mstore(0xa0, m5)
12405
            mstore(0xc0, m6)
12406
        }
12407
    }
12408

                            
                        
12409
    function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {
12410
        bytes32 m0;
12411
        bytes32 m1;
12412
        bytes32 m2;
12413
        bytes32 m3;
12414
        bytes32 m4;
12415
        bytes32 m5;
12416
        bytes32 m6;
12417
        bytes32 m7;
12418
        bytes32 m8;
12419
        /// @solidity memory-safe-assembly
12420
        assembly {
12421
            function writeString(pos, w) {
12422
                let length := 0
12423
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12424
                mstore(pos, length)
12425
                let shift := sub(256, shl(3, length))
12426
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12427
            }
12428
            m0 := mload(0x00)
12429
            m1 := mload(0x20)
12430
            m2 := mload(0x40)
12431
            m3 := mload(0x60)
12432
            m4 := mload(0x80)
12433
            m5 := mload(0xa0)
12434
            m6 := mload(0xc0)
12435
            m7 := mload(0xe0)
12436
            m8 := mload(0x100)
12437
            // Selector of `log(string,uint256,address,string)`.
12438
            mstore(0x00, 0x9ffb2f93)
12439
            mstore(0x20, 0x80)
12440
            mstore(0x40, p1)
12441
            mstore(0x60, p2)
12442
            mstore(0x80, 0xc0)
12443
            writeString(0xa0, p0)
12444
            writeString(0xe0, p3)
12445
        }
12446
        _sendLogPayload(0x1c, 0x104);
12447
        /// @solidity memory-safe-assembly
12448
        assembly {
12449
            mstore(0x00, m0)
12450
            mstore(0x20, m1)
12451
            mstore(0x40, m2)
12452
            mstore(0x60, m3)
12453
            mstore(0x80, m4)
12454
            mstore(0xa0, m5)
12455
            mstore(0xc0, m6)
12456
            mstore(0xe0, m7)
12457
            mstore(0x100, m8)
12458
        }
12459
    }
12460

                            
                        
12461
    function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {
12462
        bytes32 m0;
12463
        bytes32 m1;
12464
        bytes32 m2;
12465
        bytes32 m3;
12466
        bytes32 m4;
12467
        bytes32 m5;
12468
        bytes32 m6;
12469
        /// @solidity memory-safe-assembly
12470
        assembly {
12471
            function writeString(pos, w) {
12472
                let length := 0
12473
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12474
                mstore(pos, length)
12475
                let shift := sub(256, shl(3, length))
12476
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12477
            }
12478
            m0 := mload(0x00)
12479
            m1 := mload(0x20)
12480
            m2 := mload(0x40)
12481
            m3 := mload(0x60)
12482
            m4 := mload(0x80)
12483
            m5 := mload(0xa0)
12484
            m6 := mload(0xc0)
12485
            // Selector of `log(string,uint256,bool,address)`.
12486
            mstore(0x00, 0xe0e95b98)
12487
            mstore(0x20, 0x80)
12488
            mstore(0x40, p1)
12489
            mstore(0x60, p2)
12490
            mstore(0x80, p3)
12491
            writeString(0xa0, p0)
12492
        }
12493
        _sendLogPayload(0x1c, 0xc4);
12494
        /// @solidity memory-safe-assembly
12495
        assembly {
12496
            mstore(0x00, m0)
12497
            mstore(0x20, m1)
12498
            mstore(0x40, m2)
12499
            mstore(0x60, m3)
12500
            mstore(0x80, m4)
12501
            mstore(0xa0, m5)
12502
            mstore(0xc0, m6)
12503
        }
12504
    }
12505

                            
                        
12506
    function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {
12507
        bytes32 m0;
12508
        bytes32 m1;
12509
        bytes32 m2;
12510
        bytes32 m3;
12511
        bytes32 m4;
12512
        bytes32 m5;
12513
        bytes32 m6;
12514
        /// @solidity memory-safe-assembly
12515
        assembly {
12516
            function writeString(pos, w) {
12517
                let length := 0
12518
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12519
                mstore(pos, length)
12520
                let shift := sub(256, shl(3, length))
12521
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12522
            }
12523
            m0 := mload(0x00)
12524
            m1 := mload(0x20)
12525
            m2 := mload(0x40)
12526
            m3 := mload(0x60)
12527
            m4 := mload(0x80)
12528
            m5 := mload(0xa0)
12529
            m6 := mload(0xc0)
12530
            // Selector of `log(string,uint256,bool,bool)`.
12531
            mstore(0x00, 0x354c36d6)
12532
            mstore(0x20, 0x80)
12533
            mstore(0x40, p1)
12534
            mstore(0x60, p2)
12535
            mstore(0x80, p3)
12536
            writeString(0xa0, p0)
12537
        }
12538
        _sendLogPayload(0x1c, 0xc4);
12539
        /// @solidity memory-safe-assembly
12540
        assembly {
12541
            mstore(0x00, m0)
12542
            mstore(0x20, m1)
12543
            mstore(0x40, m2)
12544
            mstore(0x60, m3)
12545
            mstore(0x80, m4)
12546
            mstore(0xa0, m5)
12547
            mstore(0xc0, m6)
12548
        }
12549
    }
12550

                            
                        
12551
    function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {
12552
        bytes32 m0;
12553
        bytes32 m1;
12554
        bytes32 m2;
12555
        bytes32 m3;
12556
        bytes32 m4;
12557
        bytes32 m5;
12558
        bytes32 m6;
12559
        /// @solidity memory-safe-assembly
12560
        assembly {
12561
            function writeString(pos, w) {
12562
                let length := 0
12563
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12564
                mstore(pos, length)
12565
                let shift := sub(256, shl(3, length))
12566
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12567
            }
12568
            m0 := mload(0x00)
12569
            m1 := mload(0x20)
12570
            m2 := mload(0x40)
12571
            m3 := mload(0x60)
12572
            m4 := mload(0x80)
12573
            m5 := mload(0xa0)
12574
            m6 := mload(0xc0)
12575
            // Selector of `log(string,uint256,bool,uint256)`.
12576
            mstore(0x00, 0xe41b6f6f)
12577
            mstore(0x20, 0x80)
12578
            mstore(0x40, p1)
12579
            mstore(0x60, p2)
12580
            mstore(0x80, p3)
12581
            writeString(0xa0, p0)
12582
        }
12583
        _sendLogPayload(0x1c, 0xc4);
12584
        /// @solidity memory-safe-assembly
12585
        assembly {
12586
            mstore(0x00, m0)
12587
            mstore(0x20, m1)
12588
            mstore(0x40, m2)
12589
            mstore(0x60, m3)
12590
            mstore(0x80, m4)
12591
            mstore(0xa0, m5)
12592
            mstore(0xc0, m6)
12593
        }
12594
    }
12595

                            
                        
12596
    function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
12597
        bytes32 m0;
12598
        bytes32 m1;
12599
        bytes32 m2;
12600
        bytes32 m3;
12601
        bytes32 m4;
12602
        bytes32 m5;
12603
        bytes32 m6;
12604
        bytes32 m7;
12605
        bytes32 m8;
12606
        /// @solidity memory-safe-assembly
12607
        assembly {
12608
            function writeString(pos, w) {
12609
                let length := 0
12610
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12611
                mstore(pos, length)
12612
                let shift := sub(256, shl(3, length))
12613
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12614
            }
12615
            m0 := mload(0x00)
12616
            m1 := mload(0x20)
12617
            m2 := mload(0x40)
12618
            m3 := mload(0x60)
12619
            m4 := mload(0x80)
12620
            m5 := mload(0xa0)
12621
            m6 := mload(0xc0)
12622
            m7 := mload(0xe0)
12623
            m8 := mload(0x100)
12624
            // Selector of `log(string,uint256,bool,string)`.
12625
            mstore(0x00, 0xabf73a98)
12626
            mstore(0x20, 0x80)
12627
            mstore(0x40, p1)
12628
            mstore(0x60, p2)
12629
            mstore(0x80, 0xc0)
12630
            writeString(0xa0, p0)
12631
            writeString(0xe0, p3)
12632
        }
12633
        _sendLogPayload(0x1c, 0x104);
12634
        /// @solidity memory-safe-assembly
12635
        assembly {
12636
            mstore(0x00, m0)
12637
            mstore(0x20, m1)
12638
            mstore(0x40, m2)
12639
            mstore(0x60, m3)
12640
            mstore(0x80, m4)
12641
            mstore(0xa0, m5)
12642
            mstore(0xc0, m6)
12643
            mstore(0xe0, m7)
12644
            mstore(0x100, m8)
12645
        }
12646
    }
12647

                            
                        
12648
    function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {
12649
        bytes32 m0;
12650
        bytes32 m1;
12651
        bytes32 m2;
12652
        bytes32 m3;
12653
        bytes32 m4;
12654
        bytes32 m5;
12655
        bytes32 m6;
12656
        /// @solidity memory-safe-assembly
12657
        assembly {
12658
            function writeString(pos, w) {
12659
                let length := 0
12660
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12661
                mstore(pos, length)
12662
                let shift := sub(256, shl(3, length))
12663
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12664
            }
12665
            m0 := mload(0x00)
12666
            m1 := mload(0x20)
12667
            m2 := mload(0x40)
12668
            m3 := mload(0x60)
12669
            m4 := mload(0x80)
12670
            m5 := mload(0xa0)
12671
            m6 := mload(0xc0)
12672
            // Selector of `log(string,uint256,uint256,address)`.
12673
            mstore(0x00, 0xe21de278)
12674
            mstore(0x20, 0x80)
12675
            mstore(0x40, p1)
12676
            mstore(0x60, p2)
12677
            mstore(0x80, p3)
12678
            writeString(0xa0, p0)
12679
        }
12680
        _sendLogPayload(0x1c, 0xc4);
12681
        /// @solidity memory-safe-assembly
12682
        assembly {
12683
            mstore(0x00, m0)
12684
            mstore(0x20, m1)
12685
            mstore(0x40, m2)
12686
            mstore(0x60, m3)
12687
            mstore(0x80, m4)
12688
            mstore(0xa0, m5)
12689
            mstore(0xc0, m6)
12690
        }
12691
    }
12692

                            
                        
12693
    function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {
12694
        bytes32 m0;
12695
        bytes32 m1;
12696
        bytes32 m2;
12697
        bytes32 m3;
12698
        bytes32 m4;
12699
        bytes32 m5;
12700
        bytes32 m6;
12701
        /// @solidity memory-safe-assembly
12702
        assembly {
12703
            function writeString(pos, w) {
12704
                let length := 0
12705
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12706
                mstore(pos, length)
12707
                let shift := sub(256, shl(3, length))
12708
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12709
            }
12710
            m0 := mload(0x00)
12711
            m1 := mload(0x20)
12712
            m2 := mload(0x40)
12713
            m3 := mload(0x60)
12714
            m4 := mload(0x80)
12715
            m5 := mload(0xa0)
12716
            m6 := mload(0xc0)
12717
            // Selector of `log(string,uint256,uint256,bool)`.
12718
            mstore(0x00, 0x7626db92)
12719
            mstore(0x20, 0x80)
12720
            mstore(0x40, p1)
12721
            mstore(0x60, p2)
12722
            mstore(0x80, p3)
12723
            writeString(0xa0, p0)
12724
        }
12725
        _sendLogPayload(0x1c, 0xc4);
12726
        /// @solidity memory-safe-assembly
12727
        assembly {
12728
            mstore(0x00, m0)
12729
            mstore(0x20, m1)
12730
            mstore(0x40, m2)
12731
            mstore(0x60, m3)
12732
            mstore(0x80, m4)
12733
            mstore(0xa0, m5)
12734
            mstore(0xc0, m6)
12735
        }
12736
    }
12737

                            
                        
12738
    function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
12739
        bytes32 m0;
12740
        bytes32 m1;
12741
        bytes32 m2;
12742
        bytes32 m3;
12743
        bytes32 m4;
12744
        bytes32 m5;
12745
        bytes32 m6;
12746
        /// @solidity memory-safe-assembly
12747
        assembly {
12748
            function writeString(pos, w) {
12749
                let length := 0
12750
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12751
                mstore(pos, length)
12752
                let shift := sub(256, shl(3, length))
12753
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12754
            }
12755
            m0 := mload(0x00)
12756
            m1 := mload(0x20)
12757
            m2 := mload(0x40)
12758
            m3 := mload(0x60)
12759
            m4 := mload(0x80)
12760
            m5 := mload(0xa0)
12761
            m6 := mload(0xc0)
12762
            // Selector of `log(string,uint256,uint256,uint256)`.
12763
            mstore(0x00, 0xa7a87853)
12764
            mstore(0x20, 0x80)
12765
            mstore(0x40, p1)
12766
            mstore(0x60, p2)
12767
            mstore(0x80, p3)
12768
            writeString(0xa0, p0)
12769
        }
12770
        _sendLogPayload(0x1c, 0xc4);
12771
        /// @solidity memory-safe-assembly
12772
        assembly {
12773
            mstore(0x00, m0)
12774
            mstore(0x20, m1)
12775
            mstore(0x40, m2)
12776
            mstore(0x60, m3)
12777
            mstore(0x80, m4)
12778
            mstore(0xa0, m5)
12779
            mstore(0xc0, m6)
12780
        }
12781
    }
12782

                            
                        
12783
    function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
12784
        bytes32 m0;
12785
        bytes32 m1;
12786
        bytes32 m2;
12787
        bytes32 m3;
12788
        bytes32 m4;
12789
        bytes32 m5;
12790
        bytes32 m6;
12791
        bytes32 m7;
12792
        bytes32 m8;
12793
        /// @solidity memory-safe-assembly
12794
        assembly {
12795
            function writeString(pos, w) {
12796
                let length := 0
12797
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12798
                mstore(pos, length)
12799
                let shift := sub(256, shl(3, length))
12800
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12801
            }
12802
            m0 := mload(0x00)
12803
            m1 := mload(0x20)
12804
            m2 := mload(0x40)
12805
            m3 := mload(0x60)
12806
            m4 := mload(0x80)
12807
            m5 := mload(0xa0)
12808
            m6 := mload(0xc0)
12809
            m7 := mload(0xe0)
12810
            m8 := mload(0x100)
12811
            // Selector of `log(string,uint256,uint256,string)`.
12812
            mstore(0x00, 0x854b3496)
12813
            mstore(0x20, 0x80)
12814
            mstore(0x40, p1)
12815
            mstore(0x60, p2)
12816
            mstore(0x80, 0xc0)
12817
            writeString(0xa0, p0)
12818
            writeString(0xe0, p3)
12819
        }
12820
        _sendLogPayload(0x1c, 0x104);
12821
        /// @solidity memory-safe-assembly
12822
        assembly {
12823
            mstore(0x00, m0)
12824
            mstore(0x20, m1)
12825
            mstore(0x40, m2)
12826
            mstore(0x60, m3)
12827
            mstore(0x80, m4)
12828
            mstore(0xa0, m5)
12829
            mstore(0xc0, m6)
12830
            mstore(0xe0, m7)
12831
            mstore(0x100, m8)
12832
        }
12833
    }
12834

                            
                        
12835
    function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {
12836
        bytes32 m0;
12837
        bytes32 m1;
12838
        bytes32 m2;
12839
        bytes32 m3;
12840
        bytes32 m4;
12841
        bytes32 m5;
12842
        bytes32 m6;
12843
        bytes32 m7;
12844
        bytes32 m8;
12845
        /// @solidity memory-safe-assembly
12846
        assembly {
12847
            function writeString(pos, w) {
12848
                let length := 0
12849
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12850
                mstore(pos, length)
12851
                let shift := sub(256, shl(3, length))
12852
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12853
            }
12854
            m0 := mload(0x00)
12855
            m1 := mload(0x20)
12856
            m2 := mload(0x40)
12857
            m3 := mload(0x60)
12858
            m4 := mload(0x80)
12859
            m5 := mload(0xa0)
12860
            m6 := mload(0xc0)
12861
            m7 := mload(0xe0)
12862
            m8 := mload(0x100)
12863
            // Selector of `log(string,uint256,string,address)`.
12864
            mstore(0x00, 0x7c4632a4)
12865
            mstore(0x20, 0x80)
12866
            mstore(0x40, p1)
12867
            mstore(0x60, 0xc0)
12868
            mstore(0x80, p3)
12869
            writeString(0xa0, p0)
12870
            writeString(0xe0, p2)
12871
        }
12872
        _sendLogPayload(0x1c, 0x104);
12873
        /// @solidity memory-safe-assembly
12874
        assembly {
12875
            mstore(0x00, m0)
12876
            mstore(0x20, m1)
12877
            mstore(0x40, m2)
12878
            mstore(0x60, m3)
12879
            mstore(0x80, m4)
12880
            mstore(0xa0, m5)
12881
            mstore(0xc0, m6)
12882
            mstore(0xe0, m7)
12883
            mstore(0x100, m8)
12884
        }
12885
    }
12886

                            
                        
12887
    function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
12888
        bytes32 m0;
12889
        bytes32 m1;
12890
        bytes32 m2;
12891
        bytes32 m3;
12892
        bytes32 m4;
12893
        bytes32 m5;
12894
        bytes32 m6;
12895
        bytes32 m7;
12896
        bytes32 m8;
12897
        /// @solidity memory-safe-assembly
12898
        assembly {
12899
            function writeString(pos, w) {
12900
                let length := 0
12901
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12902
                mstore(pos, length)
12903
                let shift := sub(256, shl(3, length))
12904
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12905
            }
12906
            m0 := mload(0x00)
12907
            m1 := mload(0x20)
12908
            m2 := mload(0x40)
12909
            m3 := mload(0x60)
12910
            m4 := mload(0x80)
12911
            m5 := mload(0xa0)
12912
            m6 := mload(0xc0)
12913
            m7 := mload(0xe0)
12914
            m8 := mload(0x100)
12915
            // Selector of `log(string,uint256,string,bool)`.
12916
            mstore(0x00, 0x7d24491d)
12917
            mstore(0x20, 0x80)
12918
            mstore(0x40, p1)
12919
            mstore(0x60, 0xc0)
12920
            mstore(0x80, p3)
12921
            writeString(0xa0, p0)
12922
            writeString(0xe0, p2)
12923
        }
12924
        _sendLogPayload(0x1c, 0x104);
12925
        /// @solidity memory-safe-assembly
12926
        assembly {
12927
            mstore(0x00, m0)
12928
            mstore(0x20, m1)
12929
            mstore(0x40, m2)
12930
            mstore(0x60, m3)
12931
            mstore(0x80, m4)
12932
            mstore(0xa0, m5)
12933
            mstore(0xc0, m6)
12934
            mstore(0xe0, m7)
12935
            mstore(0x100, m8)
12936
        }
12937
    }
12938

                            
                        
12939
    function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
12940
        bytes32 m0;
12941
        bytes32 m1;
12942
        bytes32 m2;
12943
        bytes32 m3;
12944
        bytes32 m4;
12945
        bytes32 m5;
12946
        bytes32 m6;
12947
        bytes32 m7;
12948
        bytes32 m8;
12949
        /// @solidity memory-safe-assembly
12950
        assembly {
12951
            function writeString(pos, w) {
12952
                let length := 0
12953
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
12954
                mstore(pos, length)
12955
                let shift := sub(256, shl(3, length))
12956
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
12957
            }
12958
            m0 := mload(0x00)
12959
            m1 := mload(0x20)
12960
            m2 := mload(0x40)
12961
            m3 := mload(0x60)
12962
            m4 := mload(0x80)
12963
            m5 := mload(0xa0)
12964
            m6 := mload(0xc0)
12965
            m7 := mload(0xe0)
12966
            m8 := mload(0x100)
12967
            // Selector of `log(string,uint256,string,uint256)`.
12968
            mstore(0x00, 0xc67ea9d1)
12969
            mstore(0x20, 0x80)
12970
            mstore(0x40, p1)
12971
            mstore(0x60, 0xc0)
12972
            mstore(0x80, p3)
12973
            writeString(0xa0, p0)
12974
            writeString(0xe0, p2)
12975
        }
12976
        _sendLogPayload(0x1c, 0x104);
12977
        /// @solidity memory-safe-assembly
12978
        assembly {
12979
            mstore(0x00, m0)
12980
            mstore(0x20, m1)
12981
            mstore(0x40, m2)
12982
            mstore(0x60, m3)
12983
            mstore(0x80, m4)
12984
            mstore(0xa0, m5)
12985
            mstore(0xc0, m6)
12986
            mstore(0xe0, m7)
12987
            mstore(0x100, m8)
12988
        }
12989
    }
12990

                            
                        
12991
    function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
12992
        bytes32 m0;
12993
        bytes32 m1;
12994
        bytes32 m2;
12995
        bytes32 m3;
12996
        bytes32 m4;
12997
        bytes32 m5;
12998
        bytes32 m6;
12999
        bytes32 m7;
13000
        bytes32 m8;
13001
        bytes32 m9;
13002
        bytes32 m10;
13003
        /// @solidity memory-safe-assembly
13004
        assembly {
13005
            function writeString(pos, w) {
13006
                let length := 0
13007
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13008
                mstore(pos, length)
13009
                let shift := sub(256, shl(3, length))
13010
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13011
            }
13012
            m0 := mload(0x00)
13013
            m1 := mload(0x20)
13014
            m2 := mload(0x40)
13015
            m3 := mload(0x60)
13016
            m4 := mload(0x80)
13017
            m5 := mload(0xa0)
13018
            m6 := mload(0xc0)
13019
            m7 := mload(0xe0)
13020
            m8 := mload(0x100)
13021
            m9 := mload(0x120)
13022
            m10 := mload(0x140)
13023
            // Selector of `log(string,uint256,string,string)`.
13024
            mstore(0x00, 0x5ab84e1f)
13025
            mstore(0x20, 0x80)
13026
            mstore(0x40, p1)
13027
            mstore(0x60, 0xc0)
13028
            mstore(0x80, 0x100)
13029
            writeString(0xa0, p0)
13030
            writeString(0xe0, p2)
13031
            writeString(0x120, p3)
13032
        }
13033
        _sendLogPayload(0x1c, 0x144);
13034
        /// @solidity memory-safe-assembly
13035
        assembly {
13036
            mstore(0x00, m0)
13037
            mstore(0x20, m1)
13038
            mstore(0x40, m2)
13039
            mstore(0x60, m3)
13040
            mstore(0x80, m4)
13041
            mstore(0xa0, m5)
13042
            mstore(0xc0, m6)
13043
            mstore(0xe0, m7)
13044
            mstore(0x100, m8)
13045
            mstore(0x120, m9)
13046
            mstore(0x140, m10)
13047
        }
13048
    }
13049

                            
                        
13050
    function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {
13051
        bytes32 m0;
13052
        bytes32 m1;
13053
        bytes32 m2;
13054
        bytes32 m3;
13055
        bytes32 m4;
13056
        bytes32 m5;
13057
        bytes32 m6;
13058
        bytes32 m7;
13059
        bytes32 m8;
13060
        /// @solidity memory-safe-assembly
13061
        assembly {
13062
            function writeString(pos, w) {
13063
                let length := 0
13064
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13065
                mstore(pos, length)
13066
                let shift := sub(256, shl(3, length))
13067
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13068
            }
13069
            m0 := mload(0x00)
13070
            m1 := mload(0x20)
13071
            m2 := mload(0x40)
13072
            m3 := mload(0x60)
13073
            m4 := mload(0x80)
13074
            m5 := mload(0xa0)
13075
            m6 := mload(0xc0)
13076
            m7 := mload(0xe0)
13077
            m8 := mload(0x100)
13078
            // Selector of `log(string,string,address,address)`.
13079
            mstore(0x00, 0x439c7bef)
13080
            mstore(0x20, 0x80)
13081
            mstore(0x40, 0xc0)
13082
            mstore(0x60, p2)
13083
            mstore(0x80, p3)
13084
            writeString(0xa0, p0)
13085
            writeString(0xe0, p1)
13086
        }
13087
        _sendLogPayload(0x1c, 0x104);
13088
        /// @solidity memory-safe-assembly
13089
        assembly {
13090
            mstore(0x00, m0)
13091
            mstore(0x20, m1)
13092
            mstore(0x40, m2)
13093
            mstore(0x60, m3)
13094
            mstore(0x80, m4)
13095
            mstore(0xa0, m5)
13096
            mstore(0xc0, m6)
13097
            mstore(0xe0, m7)
13098
            mstore(0x100, m8)
13099
        }
13100
    }
13101

                            
                        
13102
    function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {
13103
        bytes32 m0;
13104
        bytes32 m1;
13105
        bytes32 m2;
13106
        bytes32 m3;
13107
        bytes32 m4;
13108
        bytes32 m5;
13109
        bytes32 m6;
13110
        bytes32 m7;
13111
        bytes32 m8;
13112
        /// @solidity memory-safe-assembly
13113
        assembly {
13114
            function writeString(pos, w) {
13115
                let length := 0
13116
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13117
                mstore(pos, length)
13118
                let shift := sub(256, shl(3, length))
13119
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13120
            }
13121
            m0 := mload(0x00)
13122
            m1 := mload(0x20)
13123
            m2 := mload(0x40)
13124
            m3 := mload(0x60)
13125
            m4 := mload(0x80)
13126
            m5 := mload(0xa0)
13127
            m6 := mload(0xc0)
13128
            m7 := mload(0xe0)
13129
            m8 := mload(0x100)
13130
            // Selector of `log(string,string,address,bool)`.
13131
            mstore(0x00, 0x5ccd4e37)
13132
            mstore(0x20, 0x80)
13133
            mstore(0x40, 0xc0)
13134
            mstore(0x60, p2)
13135
            mstore(0x80, p3)
13136
            writeString(0xa0, p0)
13137
            writeString(0xe0, p1)
13138
        }
13139
        _sendLogPayload(0x1c, 0x104);
13140
        /// @solidity memory-safe-assembly
13141
        assembly {
13142
            mstore(0x00, m0)
13143
            mstore(0x20, m1)
13144
            mstore(0x40, m2)
13145
            mstore(0x60, m3)
13146
            mstore(0x80, m4)
13147
            mstore(0xa0, m5)
13148
            mstore(0xc0, m6)
13149
            mstore(0xe0, m7)
13150
            mstore(0x100, m8)
13151
        }
13152
    }
13153

                            
                        
13154
    function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {
13155
        bytes32 m0;
13156
        bytes32 m1;
13157
        bytes32 m2;
13158
        bytes32 m3;
13159
        bytes32 m4;
13160
        bytes32 m5;
13161
        bytes32 m6;
13162
        bytes32 m7;
13163
        bytes32 m8;
13164
        /// @solidity memory-safe-assembly
13165
        assembly {
13166
            function writeString(pos, w) {
13167
                let length := 0
13168
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13169
                mstore(pos, length)
13170
                let shift := sub(256, shl(3, length))
13171
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13172
            }
13173
            m0 := mload(0x00)
13174
            m1 := mload(0x20)
13175
            m2 := mload(0x40)
13176
            m3 := mload(0x60)
13177
            m4 := mload(0x80)
13178
            m5 := mload(0xa0)
13179
            m6 := mload(0xc0)
13180
            m7 := mload(0xe0)
13181
            m8 := mload(0x100)
13182
            // Selector of `log(string,string,address,uint256)`.
13183
            mstore(0x00, 0x7cc3c607)
13184
            mstore(0x20, 0x80)
13185
            mstore(0x40, 0xc0)
13186
            mstore(0x60, p2)
13187
            mstore(0x80, p3)
13188
            writeString(0xa0, p0)
13189
            writeString(0xe0, p1)
13190
        }
13191
        _sendLogPayload(0x1c, 0x104);
13192
        /// @solidity memory-safe-assembly
13193
        assembly {
13194
            mstore(0x00, m0)
13195
            mstore(0x20, m1)
13196
            mstore(0x40, m2)
13197
            mstore(0x60, m3)
13198
            mstore(0x80, m4)
13199
            mstore(0xa0, m5)
13200
            mstore(0xc0, m6)
13201
            mstore(0xe0, m7)
13202
            mstore(0x100, m8)
13203
        }
13204
    }
13205

                            
                        
13206
    function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
13207
        bytes32 m0;
13208
        bytes32 m1;
13209
        bytes32 m2;
13210
        bytes32 m3;
13211
        bytes32 m4;
13212
        bytes32 m5;
13213
        bytes32 m6;
13214
        bytes32 m7;
13215
        bytes32 m8;
13216
        bytes32 m9;
13217
        bytes32 m10;
13218
        /// @solidity memory-safe-assembly
13219
        assembly {
13220
            function writeString(pos, w) {
13221
                let length := 0
13222
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13223
                mstore(pos, length)
13224
                let shift := sub(256, shl(3, length))
13225
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13226
            }
13227
            m0 := mload(0x00)
13228
            m1 := mload(0x20)
13229
            m2 := mload(0x40)
13230
            m3 := mload(0x60)
13231
            m4 := mload(0x80)
13232
            m5 := mload(0xa0)
13233
            m6 := mload(0xc0)
13234
            m7 := mload(0xe0)
13235
            m8 := mload(0x100)
13236
            m9 := mload(0x120)
13237
            m10 := mload(0x140)
13238
            // Selector of `log(string,string,address,string)`.
13239
            mstore(0x00, 0xeb1bff80)
13240
            mstore(0x20, 0x80)
13241
            mstore(0x40, 0xc0)
13242
            mstore(0x60, p2)
13243
            mstore(0x80, 0x100)
13244
            writeString(0xa0, p0)
13245
            writeString(0xe0, p1)
13246
            writeString(0x120, p3)
13247
        }
13248
        _sendLogPayload(0x1c, 0x144);
13249
        /// @solidity memory-safe-assembly
13250
        assembly {
13251
            mstore(0x00, m0)
13252
            mstore(0x20, m1)
13253
            mstore(0x40, m2)
13254
            mstore(0x60, m3)
13255
            mstore(0x80, m4)
13256
            mstore(0xa0, m5)
13257
            mstore(0xc0, m6)
13258
            mstore(0xe0, m7)
13259
            mstore(0x100, m8)
13260
            mstore(0x120, m9)
13261
            mstore(0x140, m10)
13262
        }
13263
    }
13264

                            
                        
13265
    function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {
13266
        bytes32 m0;
13267
        bytes32 m1;
13268
        bytes32 m2;
13269
        bytes32 m3;
13270
        bytes32 m4;
13271
        bytes32 m5;
13272
        bytes32 m6;
13273
        bytes32 m7;
13274
        bytes32 m8;
13275
        /// @solidity memory-safe-assembly
13276
        assembly {
13277
            function writeString(pos, w) {
13278
                let length := 0
13279
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13280
                mstore(pos, length)
13281
                let shift := sub(256, shl(3, length))
13282
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13283
            }
13284
            m0 := mload(0x00)
13285
            m1 := mload(0x20)
13286
            m2 := mload(0x40)
13287
            m3 := mload(0x60)
13288
            m4 := mload(0x80)
13289
            m5 := mload(0xa0)
13290
            m6 := mload(0xc0)
13291
            m7 := mload(0xe0)
13292
            m8 := mload(0x100)
13293
            // Selector of `log(string,string,bool,address)`.
13294
            mstore(0x00, 0xc371c7db)
13295
            mstore(0x20, 0x80)
13296
            mstore(0x40, 0xc0)
13297
            mstore(0x60, p2)
13298
            mstore(0x80, p3)
13299
            writeString(0xa0, p0)
13300
            writeString(0xe0, p1)
13301
        }
13302
        _sendLogPayload(0x1c, 0x104);
13303
        /// @solidity memory-safe-assembly
13304
        assembly {
13305
            mstore(0x00, m0)
13306
            mstore(0x20, m1)
13307
            mstore(0x40, m2)
13308
            mstore(0x60, m3)
13309
            mstore(0x80, m4)
13310
            mstore(0xa0, m5)
13311
            mstore(0xc0, m6)
13312
            mstore(0xe0, m7)
13313
            mstore(0x100, m8)
13314
        }
13315
    }
13316

                            
                        
13317
    function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {
13318
        bytes32 m0;
13319
        bytes32 m1;
13320
        bytes32 m2;
13321
        bytes32 m3;
13322
        bytes32 m4;
13323
        bytes32 m5;
13324
        bytes32 m6;
13325
        bytes32 m7;
13326
        bytes32 m8;
13327
        /// @solidity memory-safe-assembly
13328
        assembly {
13329
            function writeString(pos, w) {
13330
                let length := 0
13331
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13332
                mstore(pos, length)
13333
                let shift := sub(256, shl(3, length))
13334
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13335
            }
13336
            m0 := mload(0x00)
13337
            m1 := mload(0x20)
13338
            m2 := mload(0x40)
13339
            m3 := mload(0x60)
13340
            m4 := mload(0x80)
13341
            m5 := mload(0xa0)
13342
            m6 := mload(0xc0)
13343
            m7 := mload(0xe0)
13344
            m8 := mload(0x100)
13345
            // Selector of `log(string,string,bool,bool)`.
13346
            mstore(0x00, 0x40785869)
13347
            mstore(0x20, 0x80)
13348
            mstore(0x40, 0xc0)
13349
            mstore(0x60, p2)
13350
            mstore(0x80, p3)
13351
            writeString(0xa0, p0)
13352
            writeString(0xe0, p1)
13353
        }
13354
        _sendLogPayload(0x1c, 0x104);
13355
        /// @solidity memory-safe-assembly
13356
        assembly {
13357
            mstore(0x00, m0)
13358
            mstore(0x20, m1)
13359
            mstore(0x40, m2)
13360
            mstore(0x60, m3)
13361
            mstore(0x80, m4)
13362
            mstore(0xa0, m5)
13363
            mstore(0xc0, m6)
13364
            mstore(0xe0, m7)
13365
            mstore(0x100, m8)
13366
        }
13367
    }
13368

                            
                        
13369
    function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
13370
        bytes32 m0;
13371
        bytes32 m1;
13372
        bytes32 m2;
13373
        bytes32 m3;
13374
        bytes32 m4;
13375
        bytes32 m5;
13376
        bytes32 m6;
13377
        bytes32 m7;
13378
        bytes32 m8;
13379
        /// @solidity memory-safe-assembly
13380
        assembly {
13381
            function writeString(pos, w) {
13382
                let length := 0
13383
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13384
                mstore(pos, length)
13385
                let shift := sub(256, shl(3, length))
13386
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13387
            }
13388
            m0 := mload(0x00)
13389
            m1 := mload(0x20)
13390
            m2 := mload(0x40)
13391
            m3 := mload(0x60)
13392
            m4 := mload(0x80)
13393
            m5 := mload(0xa0)
13394
            m6 := mload(0xc0)
13395
            m7 := mload(0xe0)
13396
            m8 := mload(0x100)
13397
            // Selector of `log(string,string,bool,uint256)`.
13398
            mstore(0x00, 0xd6aefad2)
13399
            mstore(0x20, 0x80)
13400
            mstore(0x40, 0xc0)
13401
            mstore(0x60, p2)
13402
            mstore(0x80, p3)
13403
            writeString(0xa0, p0)
13404
            writeString(0xe0, p1)
13405
        }
13406
        _sendLogPayload(0x1c, 0x104);
13407
        /// @solidity memory-safe-assembly
13408
        assembly {
13409
            mstore(0x00, m0)
13410
            mstore(0x20, m1)
13411
            mstore(0x40, m2)
13412
            mstore(0x60, m3)
13413
            mstore(0x80, m4)
13414
            mstore(0xa0, m5)
13415
            mstore(0xc0, m6)
13416
            mstore(0xe0, m7)
13417
            mstore(0x100, m8)
13418
        }
13419
    }
13420

                            
                        
13421
    function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
13422
        bytes32 m0;
13423
        bytes32 m1;
13424
        bytes32 m2;
13425
        bytes32 m3;
13426
        bytes32 m4;
13427
        bytes32 m5;
13428
        bytes32 m6;
13429
        bytes32 m7;
13430
        bytes32 m8;
13431
        bytes32 m9;
13432
        bytes32 m10;
13433
        /// @solidity memory-safe-assembly
13434
        assembly {
13435
            function writeString(pos, w) {
13436
                let length := 0
13437
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13438
                mstore(pos, length)
13439
                let shift := sub(256, shl(3, length))
13440
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13441
            }
13442
            m0 := mload(0x00)
13443
            m1 := mload(0x20)
13444
            m2 := mload(0x40)
13445
            m3 := mload(0x60)
13446
            m4 := mload(0x80)
13447
            m5 := mload(0xa0)
13448
            m6 := mload(0xc0)
13449
            m7 := mload(0xe0)
13450
            m8 := mload(0x100)
13451
            m9 := mload(0x120)
13452
            m10 := mload(0x140)
13453
            // Selector of `log(string,string,bool,string)`.
13454
            mstore(0x00, 0x5e84b0ea)
13455
            mstore(0x20, 0x80)
13456
            mstore(0x40, 0xc0)
13457
            mstore(0x60, p2)
13458
            mstore(0x80, 0x100)
13459
            writeString(0xa0, p0)
13460
            writeString(0xe0, p1)
13461
            writeString(0x120, p3)
13462
        }
13463
        _sendLogPayload(0x1c, 0x144);
13464
        /// @solidity memory-safe-assembly
13465
        assembly {
13466
            mstore(0x00, m0)
13467
            mstore(0x20, m1)
13468
            mstore(0x40, m2)
13469
            mstore(0x60, m3)
13470
            mstore(0x80, m4)
13471
            mstore(0xa0, m5)
13472
            mstore(0xc0, m6)
13473
            mstore(0xe0, m7)
13474
            mstore(0x100, m8)
13475
            mstore(0x120, m9)
13476
            mstore(0x140, m10)
13477
        }
13478
    }
13479

                            
                        
13480
    function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {
13481
        bytes32 m0;
13482
        bytes32 m1;
13483
        bytes32 m2;
13484
        bytes32 m3;
13485
        bytes32 m4;
13486
        bytes32 m5;
13487
        bytes32 m6;
13488
        bytes32 m7;
13489
        bytes32 m8;
13490
        /// @solidity memory-safe-assembly
13491
        assembly {
13492
            function writeString(pos, w) {
13493
                let length := 0
13494
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13495
                mstore(pos, length)
13496
                let shift := sub(256, shl(3, length))
13497
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13498
            }
13499
            m0 := mload(0x00)
13500
            m1 := mload(0x20)
13501
            m2 := mload(0x40)
13502
            m3 := mload(0x60)
13503
            m4 := mload(0x80)
13504
            m5 := mload(0xa0)
13505
            m6 := mload(0xc0)
13506
            m7 := mload(0xe0)
13507
            m8 := mload(0x100)
13508
            // Selector of `log(string,string,uint256,address)`.
13509
            mstore(0x00, 0x1023f7b2)
13510
            mstore(0x20, 0x80)
13511
            mstore(0x40, 0xc0)
13512
            mstore(0x60, p2)
13513
            mstore(0x80, p3)
13514
            writeString(0xa0, p0)
13515
            writeString(0xe0, p1)
13516
        }
13517
        _sendLogPayload(0x1c, 0x104);
13518
        /// @solidity memory-safe-assembly
13519
        assembly {
13520
            mstore(0x00, m0)
13521
            mstore(0x20, m1)
13522
            mstore(0x40, m2)
13523
            mstore(0x60, m3)
13524
            mstore(0x80, m4)
13525
            mstore(0xa0, m5)
13526
            mstore(0xc0, m6)
13527
            mstore(0xe0, m7)
13528
            mstore(0x100, m8)
13529
        }
13530
    }
13531

                            
                        
13532
    function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
13533
        bytes32 m0;
13534
        bytes32 m1;
13535
        bytes32 m2;
13536
        bytes32 m3;
13537
        bytes32 m4;
13538
        bytes32 m5;
13539
        bytes32 m6;
13540
        bytes32 m7;
13541
        bytes32 m8;
13542
        /// @solidity memory-safe-assembly
13543
        assembly {
13544
            function writeString(pos, w) {
13545
                let length := 0
13546
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13547
                mstore(pos, length)
13548
                let shift := sub(256, shl(3, length))
13549
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13550
            }
13551
            m0 := mload(0x00)
13552
            m1 := mload(0x20)
13553
            m2 := mload(0x40)
13554
            m3 := mload(0x60)
13555
            m4 := mload(0x80)
13556
            m5 := mload(0xa0)
13557
            m6 := mload(0xc0)
13558
            m7 := mload(0xe0)
13559
            m8 := mload(0x100)
13560
            // Selector of `log(string,string,uint256,bool)`.
13561
            mstore(0x00, 0xc3a8a654)
13562
            mstore(0x20, 0x80)
13563
            mstore(0x40, 0xc0)
13564
            mstore(0x60, p2)
13565
            mstore(0x80, p3)
13566
            writeString(0xa0, p0)
13567
            writeString(0xe0, p1)
13568
        }
13569
        _sendLogPayload(0x1c, 0x104);
13570
        /// @solidity memory-safe-assembly
13571
        assembly {
13572
            mstore(0x00, m0)
13573
            mstore(0x20, m1)
13574
            mstore(0x40, m2)
13575
            mstore(0x60, m3)
13576
            mstore(0x80, m4)
13577
            mstore(0xa0, m5)
13578
            mstore(0xc0, m6)
13579
            mstore(0xe0, m7)
13580
            mstore(0x100, m8)
13581
        }
13582
    }
13583

                            
                        
13584
    function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
13585
        bytes32 m0;
13586
        bytes32 m1;
13587
        bytes32 m2;
13588
        bytes32 m3;
13589
        bytes32 m4;
13590
        bytes32 m5;
13591
        bytes32 m6;
13592
        bytes32 m7;
13593
        bytes32 m8;
13594
        /// @solidity memory-safe-assembly
13595
        assembly {
13596
            function writeString(pos, w) {
13597
                let length := 0
13598
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13599
                mstore(pos, length)
13600
                let shift := sub(256, shl(3, length))
13601
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13602
            }
13603
            m0 := mload(0x00)
13604
            m1 := mload(0x20)
13605
            m2 := mload(0x40)
13606
            m3 := mload(0x60)
13607
            m4 := mload(0x80)
13608
            m5 := mload(0xa0)
13609
            m6 := mload(0xc0)
13610
            m7 := mload(0xe0)
13611
            m8 := mload(0x100)
13612
            // Selector of `log(string,string,uint256,uint256)`.
13613
            mstore(0x00, 0xf45d7d2c)
13614
            mstore(0x20, 0x80)
13615
            mstore(0x40, 0xc0)
13616
            mstore(0x60, p2)
13617
            mstore(0x80, p3)
13618
            writeString(0xa0, p0)
13619
            writeString(0xe0, p1)
13620
        }
13621
        _sendLogPayload(0x1c, 0x104);
13622
        /// @solidity memory-safe-assembly
13623
        assembly {
13624
            mstore(0x00, m0)
13625
            mstore(0x20, m1)
13626
            mstore(0x40, m2)
13627
            mstore(0x60, m3)
13628
            mstore(0x80, m4)
13629
            mstore(0xa0, m5)
13630
            mstore(0xc0, m6)
13631
            mstore(0xe0, m7)
13632
            mstore(0x100, m8)
13633
        }
13634
    }
13635

                            
                        
13636
    function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
13637
        bytes32 m0;
13638
        bytes32 m1;
13639
        bytes32 m2;
13640
        bytes32 m3;
13641
        bytes32 m4;
13642
        bytes32 m5;
13643
        bytes32 m6;
13644
        bytes32 m7;
13645
        bytes32 m8;
13646
        bytes32 m9;
13647
        bytes32 m10;
13648
        /// @solidity memory-safe-assembly
13649
        assembly {
13650
            function writeString(pos, w) {
13651
                let length := 0
13652
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13653
                mstore(pos, length)
13654
                let shift := sub(256, shl(3, length))
13655
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13656
            }
13657
            m0 := mload(0x00)
13658
            m1 := mload(0x20)
13659
            m2 := mload(0x40)
13660
            m3 := mload(0x60)
13661
            m4 := mload(0x80)
13662
            m5 := mload(0xa0)
13663
            m6 := mload(0xc0)
13664
            m7 := mload(0xe0)
13665
            m8 := mload(0x100)
13666
            m9 := mload(0x120)
13667
            m10 := mload(0x140)
13668
            // Selector of `log(string,string,uint256,string)`.
13669
            mstore(0x00, 0x5d1a971a)
13670
            mstore(0x20, 0x80)
13671
            mstore(0x40, 0xc0)
13672
            mstore(0x60, p2)
13673
            mstore(0x80, 0x100)
13674
            writeString(0xa0, p0)
13675
            writeString(0xe0, p1)
13676
            writeString(0x120, p3)
13677
        }
13678
        _sendLogPayload(0x1c, 0x144);
13679
        /// @solidity memory-safe-assembly
13680
        assembly {
13681
            mstore(0x00, m0)
13682
            mstore(0x20, m1)
13683
            mstore(0x40, m2)
13684
            mstore(0x60, m3)
13685
            mstore(0x80, m4)
13686
            mstore(0xa0, m5)
13687
            mstore(0xc0, m6)
13688
            mstore(0xe0, m7)
13689
            mstore(0x100, m8)
13690
            mstore(0x120, m9)
13691
            mstore(0x140, m10)
13692
        }
13693
    }
13694

                            
                        
13695
    function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
13696
        bytes32 m0;
13697
        bytes32 m1;
13698
        bytes32 m2;
13699
        bytes32 m3;
13700
        bytes32 m4;
13701
        bytes32 m5;
13702
        bytes32 m6;
13703
        bytes32 m7;
13704
        bytes32 m8;
13705
        bytes32 m9;
13706
        bytes32 m10;
13707
        /// @solidity memory-safe-assembly
13708
        assembly {
13709
            function writeString(pos, w) {
13710
                let length := 0
13711
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13712
                mstore(pos, length)
13713
                let shift := sub(256, shl(3, length))
13714
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13715
            }
13716
            m0 := mload(0x00)
13717
            m1 := mload(0x20)
13718
            m2 := mload(0x40)
13719
            m3 := mload(0x60)
13720
            m4 := mload(0x80)
13721
            m5 := mload(0xa0)
13722
            m6 := mload(0xc0)
13723
            m7 := mload(0xe0)
13724
            m8 := mload(0x100)
13725
            m9 := mload(0x120)
13726
            m10 := mload(0x140)
13727
            // Selector of `log(string,string,string,address)`.
13728
            mstore(0x00, 0x6d572f44)
13729
            mstore(0x20, 0x80)
13730
            mstore(0x40, 0xc0)
13731
            mstore(0x60, 0x100)
13732
            mstore(0x80, p3)
13733
            writeString(0xa0, p0)
13734
            writeString(0xe0, p1)
13735
            writeString(0x120, p2)
13736
        }
13737
        _sendLogPayload(0x1c, 0x144);
13738
        /// @solidity memory-safe-assembly
13739
        assembly {
13740
            mstore(0x00, m0)
13741
            mstore(0x20, m1)
13742
            mstore(0x40, m2)
13743
            mstore(0x60, m3)
13744
            mstore(0x80, m4)
13745
            mstore(0xa0, m5)
13746
            mstore(0xc0, m6)
13747
            mstore(0xe0, m7)
13748
            mstore(0x100, m8)
13749
            mstore(0x120, m9)
13750
            mstore(0x140, m10)
13751
        }
13752
    }
13753

                            
                        
13754
    function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
13755
        bytes32 m0;
13756
        bytes32 m1;
13757
        bytes32 m2;
13758
        bytes32 m3;
13759
        bytes32 m4;
13760
        bytes32 m5;
13761
        bytes32 m6;
13762
        bytes32 m7;
13763
        bytes32 m8;
13764
        bytes32 m9;
13765
        bytes32 m10;
13766
        /// @solidity memory-safe-assembly
13767
        assembly {
13768
            function writeString(pos, w) {
13769
                let length := 0
13770
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13771
                mstore(pos, length)
13772
                let shift := sub(256, shl(3, length))
13773
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13774
            }
13775
            m0 := mload(0x00)
13776
            m1 := mload(0x20)
13777
            m2 := mload(0x40)
13778
            m3 := mload(0x60)
13779
            m4 := mload(0x80)
13780
            m5 := mload(0xa0)
13781
            m6 := mload(0xc0)
13782
            m7 := mload(0xe0)
13783
            m8 := mload(0x100)
13784
            m9 := mload(0x120)
13785
            m10 := mload(0x140)
13786
            // Selector of `log(string,string,string,bool)`.
13787
            mstore(0x00, 0x2c1754ed)
13788
            mstore(0x20, 0x80)
13789
            mstore(0x40, 0xc0)
13790
            mstore(0x60, 0x100)
13791
            mstore(0x80, p3)
13792
            writeString(0xa0, p0)
13793
            writeString(0xe0, p1)
13794
            writeString(0x120, p2)
13795
        }
13796
        _sendLogPayload(0x1c, 0x144);
13797
        /// @solidity memory-safe-assembly
13798
        assembly {
13799
            mstore(0x00, m0)
13800
            mstore(0x20, m1)
13801
            mstore(0x40, m2)
13802
            mstore(0x60, m3)
13803
            mstore(0x80, m4)
13804
            mstore(0xa0, m5)
13805
            mstore(0xc0, m6)
13806
            mstore(0xe0, m7)
13807
            mstore(0x100, m8)
13808
            mstore(0x120, m9)
13809
            mstore(0x140, m10)
13810
        }
13811
    }
13812

                            
                        
13813
    function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
13814
        bytes32 m0;
13815
        bytes32 m1;
13816
        bytes32 m2;
13817
        bytes32 m3;
13818
        bytes32 m4;
13819
        bytes32 m5;
13820
        bytes32 m6;
13821
        bytes32 m7;
13822
        bytes32 m8;
13823
        bytes32 m9;
13824
        bytes32 m10;
13825
        /// @solidity memory-safe-assembly
13826
        assembly {
13827
            function writeString(pos, w) {
13828
                let length := 0
13829
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13830
                mstore(pos, length)
13831
                let shift := sub(256, shl(3, length))
13832
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13833
            }
13834
            m0 := mload(0x00)
13835
            m1 := mload(0x20)
13836
            m2 := mload(0x40)
13837
            m3 := mload(0x60)
13838
            m4 := mload(0x80)
13839
            m5 := mload(0xa0)
13840
            m6 := mload(0xc0)
13841
            m7 := mload(0xe0)
13842
            m8 := mload(0x100)
13843
            m9 := mload(0x120)
13844
            m10 := mload(0x140)
13845
            // Selector of `log(string,string,string,uint256)`.
13846
            mstore(0x00, 0x8eafb02b)
13847
            mstore(0x20, 0x80)
13848
            mstore(0x40, 0xc0)
13849
            mstore(0x60, 0x100)
13850
            mstore(0x80, p3)
13851
            writeString(0xa0, p0)
13852
            writeString(0xe0, p1)
13853
            writeString(0x120, p2)
13854
        }
13855
        _sendLogPayload(0x1c, 0x144);
13856
        /// @solidity memory-safe-assembly
13857
        assembly {
13858
            mstore(0x00, m0)
13859
            mstore(0x20, m1)
13860
            mstore(0x40, m2)
13861
            mstore(0x60, m3)
13862
            mstore(0x80, m4)
13863
            mstore(0xa0, m5)
13864
            mstore(0xc0, m6)
13865
            mstore(0xe0, m7)
13866
            mstore(0x100, m8)
13867
            mstore(0x120, m9)
13868
            mstore(0x140, m10)
13869
        }
13870
    }
13871

                            
                        
13872
    function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
13873
        bytes32 m0;
13874
        bytes32 m1;
13875
        bytes32 m2;
13876
        bytes32 m3;
13877
        bytes32 m4;
13878
        bytes32 m5;
13879
        bytes32 m6;
13880
        bytes32 m7;
13881
        bytes32 m8;
13882
        bytes32 m9;
13883
        bytes32 m10;
13884
        bytes32 m11;
13885
        bytes32 m12;
13886
        /// @solidity memory-safe-assembly
13887
        assembly {
13888
            function writeString(pos, w) {
13889
                let length := 0
13890
                for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
13891
                mstore(pos, length)
13892
                let shift := sub(256, shl(3, length))
13893
                mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
13894
            }
13895
            m0 := mload(0x00)
13896
            m1 := mload(0x20)
13897
            m2 := mload(0x40)
13898
            m3 := mload(0x60)
13899
            m4 := mload(0x80)
13900
            m5 := mload(0xa0)
13901
            m6 := mload(0xc0)
13902
            m7 := mload(0xe0)
13903
            m8 := mload(0x100)
13904
            m9 := mload(0x120)
13905
            m10 := mload(0x140)
13906
            m11 := mload(0x160)
13907
            m12 := mload(0x180)
13908
            // Selector of `log(string,string,string,string)`.
13909
            mstore(0x00, 0xde68f20a)
13910
            mstore(0x20, 0x80)
13911
            mstore(0x40, 0xc0)
13912
            mstore(0x60, 0x100)
13913
            mstore(0x80, 0x140)
13914
            writeString(0xa0, p0)
13915
            writeString(0xe0, p1)
13916
            writeString(0x120, p2)
13917
            writeString(0x160, p3)
13918
        }
13919
        _sendLogPayload(0x1c, 0x184);
13920
        /// @solidity memory-safe-assembly
13921
        assembly {
13922
            mstore(0x00, m0)
13923
            mstore(0x20, m1)
13924
            mstore(0x40, m2)
13925
            mstore(0x60, m3)
13926
            mstore(0x80, m4)
13927
            mstore(0xa0, m5)
13928
            mstore(0xc0, m6)
13929
            mstore(0xe0, m7)
13930
            mstore(0x100, m8)
13931
            mstore(0x120, m9)
13932
            mstore(0x140, m10)
13933
            mstore(0x160, m11)
13934
            mstore(0x180, m12)
13935
        }
13936
    }
13937
}
13938

                            
                        

Lines covered: 0 / 3 (0.0%)

1
// SPDX-License-Identifier: UNLICENSED
2
pragma solidity ^0.8.13;
3

                            
                        
4
import {Script, console} from "forge-std/Script.sol";
5

                            
                        
6
contract CounterScript is Script {
7
    function setUp() public {}
8

                            
                        
9
    function run() public {
10
        vm.broadcast();
11
    }
12
}
13

                            
                        

Lines covered: 7 / 7 (100.0%)

1
// SPDX-License-Identifier: UNLICENSED
2
pragma solidity ^0.8.13;
3

                            
                        
4
contract Counter {
5
    uint256 public number = 1;
6

                            
                        
7
    /// @notice sets the value of the number variable
8
    /// @notice number can never be set to 0
9
    /// @param newNumber the value to set number to
10
    function setNumber(uint256 newNumber) public {
11
        if (newNumber != 0) {
12
            number = newNumber;
13
        }
14
    }
15

                            
                        
16
    /// @notice increments the existing number value
17
    function increment() public {
18
        number++;
19
        _incrementHelper();
20
    }
21

                            
                        
22
    function _incrementHelper() internal {
23
        if(number == 5) {
24
            number = 0;
25
        }
26
    }
27
}
28

                            
                        

Lines covered: 0 / 8 (0.0%)

1
// SPDX-License-Identifier: UNLICENSED
2
pragma solidity ^0.8.13;
3

                            
                        
4
import {Test, console} from "forge-std/Test.sol";
5
import {Counter} from "../src/Counter.sol";
6

                            
                        
7
contract CounterTest is Test {
8
    Counter public counter;
9

                            
                        
10
    function setUp() public {
11
        counter = new Counter();
12
        counter.setNumber(0);
13
    }
14

                            
                        
15
    function test_Increment() public {
16
        counter.increment();
17
        assertEq(counter.number(), 1);
18
    }
19

                            
                        
20
    function testFuzz_SetNumber(uint256 x) public {
21
        counter.setNumber(x);
22
        assertEq(counter.number(), x);
23
    }
24
}
25

                            
                        

Lines covered: 0 / 0 (0.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {Setup} from "./Setup.sol";
6

                            
                        
7
abstract contract BeforeAfter is Setup {
8

                            
                        
9
    // struct Vars {
10

                            
                        
11
    // }
12

                            
                        
13
    // Vars internal _before;
14
    // Vars internal _after;
15

                            
                        
16
    // function __before() internal {
17

                            
                        
18
    // }
19

                            
                        
20
    // function __after() internal {
21

                            
                        
22
    // }
23
}
24

                            
                        

Lines covered: 2 / 2 (100.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {TargetFunctions} from "./TargetFunctions.sol";
6
import {CryticAsserts} from "@chimera/CryticAsserts.sol";
7

                            
                        
8
// echidna . --contract CryticTester --config echidna.yaml
9
// medusa fuzz
10
contract CryticTester is TargetFunctions, CryticAsserts {
11
    constructor() payable {
12
        setup();
13
    }
14
}
15

                            
                        

Lines covered: 0 / 2 (0.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {Test} from "forge-std/Test.sol";
6
import {TargetFunctions} from "./TargetFunctions.sol";
7
import {FoundryAsserts} from "@chimera/FoundryAsserts.sol";
8

                            
                        
9
contract CryticToFoundry is Test, TargetFunctions, FoundryAsserts {
10
    function setUp() public {
11
        setup();
12
    }
13

                            
                        
14
    function testDemo() public {
15
        // TODO: Given any target function and foundry assert, test your results
16
    }
17
}
18

                            
                        

Lines covered: 2 / 2 (100.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {Asserts} from "@chimera/Asserts.sol";
6
import {Setup} from "./Setup.sol";
7

                            
                        
8
abstract contract Properties is Setup, Asserts {
9
  function crytic_counter_never_zero() public returns(bool) {
10
    return counter.number() != 0;
11
  }
12
}
13

                            
                        

Lines covered: 1 / 1 (100.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {BaseSetup} from "@chimera/BaseSetup.sol";
6

                            
                        
7
import "src/Counter.sol";
8

                            
                        
9
abstract contract Setup is BaseSetup {
10

                            
                        
11
    Counter counter;
12

                            
                        
13
    function setup() internal virtual override {
14
      counter = new Counter(); // TODO: Add parameters here
15
    }
16
}
17

                            
                        

Lines covered: 2 / 2 (100.0%)

1

                            
                        
2
// SPDX-License-Identifier: GPL-2.0
3
pragma solidity ^0.8.0;
4

                            
                        
5
import {BaseTargetFunctions} from "@chimera/BaseTargetFunctions.sol";
6
import {BeforeAfter} from "./BeforeAfter.sol";
7
import {Properties} from "./Properties.sol";
8
import {vm} from "@chimera/Hevm.sol";
9

                            
                        
10
abstract contract TargetFunctions is BaseTargetFunctions, Properties, BeforeAfter {
11

                            
                        
12
    function counter_increment() public {
13
        counter.increment();
14
    }
15

                            
                        
16
    function counter_setNumber(uint256 newNumber) public {
17
        counter.setNumber(newNumber);
18
    }
19
}
20